OwlCyberSecurity - MANAGER
Edit File: collections.cpython-38.pyc
U ��]| � @ s� d Z ddlZddlmZ ddlZddlZddlm Z m Z m Z m Z m ZmZmZmZmZ ddlZe �ddgdd gd d gd d dgddgd��G dd� de je j��Zejjdd� G dd� de�Z G dd� de �Z G dd� de �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 d0d1� d1e�Z)e �*e�Z+d2D ]Z,ej�e,e+i� �q�ejje �*e#�d3� dS )4ay Classes for the efficient drawing of large collections of objects that share most properties, e.g., a large number of line segments or polygons. The classes are not meant to be as flexible as their single element counterparts (e.g., you may not be able to select all line styles) but they are meant to be fast for common use cases (e.g., a large set of solid line segments). � N)�Number� ) �_path�artist�cbook�cm�colors� docstring�lines�path� transforms� antialiaseds�aa� edgecolorsZec� facecolorsZfc� linestyles�dashes�ls� linewidths�lw)� antialiasedZ edgecolorZ facecolor� linestyle� linewidthc @ s� e Zd ZdZe�d�Ze�� Z e� d�Z dZ d\d d �Z d d � Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zejdd� �Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Z d&d'� Z d(d)� Z d*d+� Z d,d-� Z d.d/� Z!d0d1� Z"d2d3� Z#d4d5� Z$d6d7� Z%d8d9� Z&d:d;� Z'd<d=� Z(e)d>d?� �Z*d@dA� Z+dBdC� Z,dDdE� Z-dFdG� Z.dHdI� Z/dJdK� Z0dLdM� Z1dNdO� Z2dPdQ� Z3dRdS� Z4dTdU� Z5dVdW� Z6dXdY� Z7dZd[� Z8dS )]� Collectiona Base class for Collections. Must be subclassed to be usable. All properties in a collection must be sequences or scalars; if scalars, they will be converted to sequences. The property of the ith element of the collection is:: prop[i % len(props)] Exceptions are *capstyle* and *joinstyle* properties, these can only be set globally for the whole collection. Keyword arguments and default values: * *edgecolors*: None * *facecolors*: None * *linewidths*: None * *capstyle*: None * *joinstyle*: None * *antialiaseds*: None * *offsets*: None * *transOffset*: transforms.IdentityTransform() * *offset_position*: 'screen' (default) or 'data' * *norm*: None (optional for :class:`matplotlib.cm.ScalarMappable`) * *cmap*: None (optional for :class:`matplotlib.cm.ScalarMappable`) * *hatch*: None * *zorder*: 1 *offsets* and *transOffset* are used to translate the patch after rendering (default no offsets). If offset_position is 'screen' (default) the offset is applied after the master transform has been applied, that is, the offsets are in screen coordinates. If offset_position is 'data', the offset is applied before the master transform, i.e., the offsets are in data coordinates. If any of *edgecolors*, *facecolors*, *linewidths*, *antialiaseds* are None, they default to their :data:`matplotlib.rcParams` patch setting, in sequence form. The use of :class:`~matplotlib.cm.ScalarMappable` is optional. If the :class:`~matplotlib.cm.ScalarMappable` matrix _A is not None (i.e., a call to set_array has been made), at draw time a call to scalar mappable will be made to set the face colors. )r � �r � r FN�solid� @�screenr c K s` t j�| � tj�| | | � dg| _dg| _dg| _dg| _d| _ t � t j d �| _| �|� | �|� | �|� | �|� | �|� | �| � | �|� | �| � | �|� | �|� |r�| �|� nd| _|r�| �|� nd| _ t � d�| _ d| _ |dk �rFt �!|t"�}|j#dk�r(|ddd�f }| dk �r@|| _ | | _$n|| _ d| _%| �&|� d| _'dS )z= Create a Collection %(Collection)s �NNr Tz hatch.colorN)r r �r )(r �Artist�__init__r �ScalarMappable�_us_linestyles� _linestyles�_us_lw� _linewidths� _is_filled�mcolors�to_rgba�mpl�rcParams� _hatch_color� set_facecolor� set_edgecolor� set_linewidth� set_linestyle�set_antialiased�set_pickradius�set_urls� set_hatch�set_offset_positionZ set_zorder� set_capstyle� _capstyle� set_joinstyle� _joinstyle�np�zeros�_offsets�_uniform_offsets� asanyarray�float�shape� _transOffsetZ _path_effects�update�_paths)�selfr r r r ZcapstyleZ joinstyler �offsets� transOffset�norm�cmap� pickradius�hatch�urls�offset_position�zorder�kwargs� rQ �8/usr/lib/python3/dist-packages/matplotlib/collections.pyr# Z sJ zCollection.__init__c C s | j S �N�rE �rF rQ rQ rR � get_paths� s zCollection.get_pathsc C s t �d S rS )�NotImplementedErrorrU rQ rQ rR � set_paths� s zCollection.set_pathsc C s | j S rS )� _transformsrU rQ rQ rR �get_transforms� s zCollection.get_transformsc C s, | j }t|tj�s(t|d�r(|�| j�}|S )N�_as_mpl_transform)rC � isinstancer Z Transform�hasattrr[ �axes)rF �trQ rQ rR �get_offset_transform� s � z Collection.get_offset_transformc s� | � � � | �� }| j}| �� }� js>� fdd�|D �}� �� � |jsV|�|�}|�� }t|tj j �rp|� tj �}t |�r�t |�r�t�� �� || �� ||�� �}|�|�}n tj�� }|S )Nc s g | ]}� � |��qS rQ �Ztransform_path_non_affine��.0�p�� transformrQ rR � <listcomp>� s z*Collection.get_datalim.<locals>.<listcomp>)� get_transformr` r> rV � is_affine� get_affine�transform_non_affiner\ r< �ma� MaskedArray�filled�nan�len�mpathZget_path_collection_extents�frozenrZ Zinverse_transformedr �BboxZnull)rF � transDatarH rG �paths�resultrQ re rR � get_datalim� s. � zCollection.get_datalimc C s | � t�� �S rS )rw r �IdentityTransform�rF �rendererrQ rQ rR �get_window_extent� s z Collection.get_window_extentc s4 | � � � | �� }| j}| �� }| �� r�g }| �� D ]^}|j}|d d �df |d d �df }}| �|�}| �|�}|�t � t � ||g�|j �� q2|jr�| �|d d �df �}| �|d d �df �}t � ||g�}� js� fdd�|D �}� �� � |j�s |�|�}|�� }t|t jj��r(|�t j�}� |||fS )Nr r c s g | ]}� � |��qS rQ ra )rc r re rQ rR rg � s �z.Collection._prepare_points.<locals>.<listcomp>)rh r` r> rV � have_units�vertices�convert_xunits�convert_yunits�appendrq �Pathr< � column_stack�codes�sizeri rj rk r\ rl rm rn ro )rF rH rG ru r r} �xs�ysrQ re rR �_prepare_points� s6 " � zCollection._prepare_pointsc C s� | � � s d S |�| jj| �� � | �� | �� \}}}}|�� }| �|� |� | � � � | j r�|� | j � z|� | j� W n" tk r� tjddd� Y nX | �� d k r�|j| �� � | �� r�ddlm} || �� |�}| �� }| �� } | �� } d} t|�dk�r�t|�dk�r�t| �dk�r�t| �dk�r�t| j�dk�r�| j dgk�r�t| j �dk�r�t| j �dk�r�| � � d k�r�t|��r�t �!|d �| } n|} |d �"| �} |�#� \}}| j$|k �r�| j%|k �r�d } | j&�r�|�'| j&� | j(�r�|�)| j(� | �r~|�*t+| d �� |�,| jd � |j-| j d � |�.| j d � |�/| j d � |�0||d | �1� t2�3|�|t+| d �� n<|�4||�1� || �� ||| �� | �� | j| j | j | j | j5� |�6� |�7| jj� d| _8d S ) Nz3.1zoYour backend does not support setting the hatch color; such backends will become unsupported in Matplotlib 3.3.)�messager )�PathEffectRendererFr r T)9� get_visible� open_group� __class__�__name__�get_gid�update_scalarmappabler� �new_gc� _set_gc_clipZset_snapZget_snap�_hatchr6 �set_hatch_colorr. �AttributeErrorr Zwarn_deprecatedZget_sketch_paramsZset_sketch_paramsZget_path_effectsZmatplotlib.patheffectsr� rZ � get_facecolor� get_edgecolorrp r( r& � _antialiaseds�_urls� get_hatchr �Affine2DZ get_extentsZget_canvas_width_height�width�heightr; r: r9 r8 Zset_foreground�tupler1 Z set_dashesr3 Zset_urlZ draw_markersrr rq r� Zdraw_path_collection�_offset_position�restore� close_group�stale)rF rz rf rH rG ru �gcr� Ztransr r Zdo_single_path_optimizationZcombined_transformZextentsr� r� rQ rQ rR �draw� s� � � � � � � � � � � �zCollection.drawc C s || _ dS )z� Set the pick radius used for containment tests. Parameters ---------- d : float Pick radius, in points. N�� _pickradius)rF ZprrQ rQ rR r4 O s zCollection.set_pickradiusc C s | j S rS r� rU rQ rQ rR �get_pickradiusZ s zCollection.get_pickradiusc C s� | j dk r| � | |�S | �� s&di fS t| jt�rF| jdk rFt| j�n| j}| �� \}}}}t� |j |j ||� � || � � |||dk| �� � }t|�dkt|d�fS )z� Test whether the mouse event occurred in the collection. Returns ``bool, dict(ind=itemlist)``, where every item in itemlist contains the event. NFTr )�ind)Z _containsr� r\ Z_pickerr rA r� r� r Zpoint_in_path_collection�x�yrr rZ �get_offset_positionrp �dict)rF Z mouseeventrK rf rH rG ru r� rQ rQ rR �contains] s0 �� � �zCollection.containsc C s |dk r |ndg| _ d| _dS )zP Parameters ---------- urls : List[str] or None NT)r� r� )rF rM rQ rQ rR r5 z s zCollection.set_urlsc C s | j S rS )r� rU rQ rQ rR �get_urls� s zCollection.get_urlsc C s || _ d| _dS )a� Set the hatching pattern *hatch* can be one of:: / - diagonal hatching \ - back diagonal | - vertical - - horizontal + - crossed x - crossed diagonal o - small circle O - large circle . - dots * - stars Letters can be combined, in which case all the specified hatchings are done. If same letter repeats, it increases the density of hatching of that pattern. Hatching is supported in the PostScript, PDF, SVG and Agg backends only. Unlike other properties such as linewidth and colors, hatching can only be specified for the collection as a whole, not separately for each member. Parameters ---------- hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'} TN)r� r� )rF rL rQ rQ rR r6 � s zCollection.set_hatchc C s | j S )z$Return the current hatching pattern.)r� rU rQ rQ rR r� � s zCollection.get_hatchc C sH t �|t�}|jdkr&|ddd�f }| jdkr8|| _n|| _d| _dS )z� Set the offsets for the collection. Parameters ---------- offsets : float or sequence of floats r! NT)r< r@ rA rB r? r> r� )rF rG rQ rQ rR � set_offsets� s zCollection.set_offsetsc C s | j dkr| jS | j S dS )z&Return the offsets for the collection.N)r? r> rU rQ rQ rR � get_offsets� s zCollection.get_offsetsc C s" t jddg|d� || _d| _dS )a� Set how offsets are applied. If *offset_position* is 'screen' (default) the offset is applied after the master transform has been applied, that is, the offsets are in screen coordinates. If offset_position is 'data', the offset is applied before the master transform, i.e., the offsets are in data coordinates. Parameters ---------- offset_position : {'screen', 'data'} r �data)rN TN)r �_check_in_listr� r� )rF rN rQ rQ rR r7 � s �z Collection.set_offset_positionc C s | j S )a� Returns how offsets are applied for the collection. If *offset_position* is 'screen', the offset is applied after the master transform has been applied, that is, the offsets are in screen coordinates. If offset_position is 'data', the offset is applied before the master transform, i.e., the offsets are in data coordinates. )r� rU rQ rQ rR r� � s z Collection.get_offset_positionc C sX |dkr$t jd }|dkr$t jd }t�t�|��| _| �| j| j�\| _| _ d| _ dS )z� Set the linewidth(s) for the collection. *lw* can be a scalar or a sequence; if it is a sequence the patches will cycle through the sequence Parameters ---------- lw : float or sequence of floats Nzpatch.linewidth�lines.linewidthT) r, r- r< � atleast_1d�asarrayr' � _bcast_lwlsr% r( r& r� )rF r rQ rQ rR r1 � s � zCollection.set_linewidthc C s� z^t |t�r(tj�||�}t�|�g}n4zt�|�g}W n" tk rZ dd� |D �}Y nX W n" tk r� td�|���Y nX || _ | � | j | j �\| _ | _ dS )a% Set the linestyle(s) for the collection. =========================== ================= linestyle description =========================== ================= ``'-'`` or ``'solid'`` solid line ``'--'`` or ``'dashed'`` dashed line ``'-.'`` or ``'dashdot'`` dash-dotted line ``':'`` or ``'dotted'`` dotted line =========================== ================= Alternatively a dash tuple of the following form can be provided:: (offset, onoffseq), where ``onoffseq`` is an even length tuple of on and off ink in points. Parameters ---------- ls : {'-', '--', '-.', ':', '', (offset, on-off-seq), ...} The line style. c S s g | ]}t �|��qS rQ )�mlines�_get_dash_pattern�rc r� rQ rQ rR rg s z,Collection.set_linestyle.<locals>.<listcomp>z)Do not know how to convert {!r} to dashesN)r\ �strr Z ls_mapper�getr� r� � ValueError�formatr% r� r' r( r& )rF r r rQ rQ rR r2 � s" � �zCollection.set_linestylec C s |dkr|| _ n td| ��dS )z� Set the capstyle for the collection (for all its elements). Parameters ---------- cs : {'butt', 'round', 'projecting'} The capstyle )Zbutt�roundZ projectingz!Unrecognized cap style. Found %sN)r9 r� )rF ZcsrQ rQ rR r8 & s zCollection.set_capstylec C s | j S rS )r9 rU rQ rQ rR � get_capstyle4 s zCollection.get_capstylec C s |dkr|| _ n td| ��dS )z� Set the joinstyle for the collection (for all its elements). Parameters ---------- js : {'miter', 'round', 'bevel'} The joinstyle )Zmiterr� Zbevelz"Unrecognized join style. Found %sN)r; r� )rF ZjsrQ rQ rR r: 7 s zCollection.set_joinstylec C s | j S rS )r; rU rQ rQ rR � get_joinstyleE s zCollection.get_joinstylec C sz t jd r| |fS t|�t| �kr^t|�}t| �}t�||�}t|�|| }t| �|| } dd� t|| �D �}| |fS )a� Internal helper function to broadcast + scale ls/lw In the collection drawing code, the linewidth and linestyle are cycled through as circular buffers (via ``v[i % len(v)]``). Thus, if we are going to scale the dash pattern at set time (not draw time) we need to do the broadcasting now and expand both lists to be the same length. Parameters ---------- linewidths : list line widths of collection dashes : list dash specification (offset, (dash pattern tuple)) Returns ------- linewidths, dashes : list Will be the same length, dashes are scaled by paired linewidth z_internal.classic_modec S s" g | ]\\}}}t �|||��qS rQ )r� Z _scale_dashes)rc �o�dr rQ rQ rR rg i s �z*Collection._bcast_lwls.<locals>.<listcomp>)r, r- rp �math�gcd�list�zip)r r Zl_dashesZl_lwr� rQ rQ rR r� H s �zCollection._bcast_lwlsc C s0 |dkrt jd }t�t�|t��| _d| _dS )z� Set the antialiasing state for rendering. Parameters ---------- aa : bool or sequence of bools Nzpatch.antialiasedT)r, r- r< r� r� �boolr� r� )rF r rQ rQ rR r3 n s zCollection.set_antialiasedc C s | � |� | �|� dS )a* Set both the edgecolor and the facecolor. Parameters ---------- c : color or sequence of rgba tuples See Also -------- Collection.set_facecolor, Collection.set_edgecolor For setting the edge or face color individually. N)r/ r0 �rF �crQ rQ rR � set_color{ s zCollection.set_colorc C s^ |d krt jd }d| _z|�� dkr,d| _W n tk rB Y nX t�|| j�| _d| _ d S )Nzpatch.facecolorT�noneF) r, r- r) �lowerr� r* � to_rgba_array�_alpha� _facecolorsr� r� rQ rQ rR �_set_facecolor� s zCollection._set_facecolorc C s || _ | �|� dS )au Set the facecolor(s) of the collection. *c* can be a matplotlib color spec (all patches have same color), or a sequence of specs; if it is a sequence the patches will cycle through the sequence. If *c* is 'none', the patch will not be filled. Parameters ---------- c : color or sequence of colors N)�_original_facecolorr� r� rQ rQ rR r/ � s zCollection.set_facecolorc C s | j S rS )r� rU rQ rQ rR r� � s zCollection.get_facecolorc C s t �| jd�r| �� S | jS d S )N�face)r Z _str_equal� _edgecolorsr� rU rQ rQ rR r� � s zCollection.get_edgecolorc C s� d}|d kr6t jd s"| jr"| jr.t jd }nd}d}d| _z|�� dkrPd| _W n tk rf Y nX z |�� dkr�d| _W d S W n tk r� Y nX t� || j �| _|r�t | j�r�t | jd �| _ d| _d S )NTzpatch.force_edgecolorzpatch.edgecolorr� Fr� r )r, r- r) � _edge_default� _is_strokedr� r� r� r* r� r� rp r� r. r� )rF r� r� rQ rQ rR �_set_edgecolor� s4 �� zCollection._set_edgecolorc C s || _ | �|� dS )a Set the edgecolor(s) of the collection. Parameters ---------- c : color or sequence of colors or 'face' The collection edgecolor(s). If a sequence, the patches cycle through it. If 'face', match the facecolor. N)�_original_edgecolorr� r� rQ rQ rR r0 � s zCollection.set_edgecolorc C sf |dk r2z t |� W n tk r0 td��Y nX d| jd< tj�| |� | �| j� | �| j � dS )z� Set the alpha transparencies of the collection. Parameters ---------- alpha : float or None Nz alpha must be a float or NoneT�array) rA � TypeErrorZ update_dictr r" � set_alphar� r� r� r� )rF �alpharQ rQ rR r� � s zCollection.set_alphac C s | j S rS )r( rU rQ rQ rR � get_linewidth� s zCollection.get_linewidthc C s | j S rS )r& rU rQ rQ rR � get_linestyle� s zCollection.get_linestylec C sl | j dkrdS | j jdkr"td��| �d�s0dS | jrJ| �| j | j�| _n| jrb| �| j | j�| _ d| _ dS )z@Update colors from the scalar mappable array, if it is not None.Nr z&Collections can only map rank 1 arraysr� T) �_A�ndimr� Z check_updater) r+ r� r� r� r� r� rU rQ rQ rR r� � s z Collection.update_scalarmappablec C s | j S )zreturn whether fill is set)r) rU rQ rQ rR �get_fill s zCollection.get_fillc C s� t j�| |� |j| _|j| _|j| _|j| _|j| _|j| _|j | _ |j | _ |j | _ |j | _ |j | _ |j| _|j| _d| _dS )z"copy properties from other to selfTN)r r" � update_fromr� r� r� r� r� r( r& r% r� r� r� rI rJ r� )rF �otherrQ rQ rR r� s zCollection.update_from)NNNr NNNNNNNr NNr r )9r� � __module__� __qualname__�__doc__r< r= r> r rx rC �emptyrY r� r# rV rX rZ r` rw r{ r� r �allow_rasterizationr� r4 r� r� r5 r� r6 r� r� r� r7 r� r1 r2 r8 r� r: r� � staticmethodr� r3 r� r� r/ r� r� r� r0 r� r� r� r� r� r� rQ rQ rQ rR r s� . � K% U # - % r a� Valid Collection keyword arguments: * *edgecolors*: None * *facecolors*: None * *linewidths*: None * *antialiaseds*: None * *offsets*: None * *transOffset*: transforms.IdentityTransform() * *norm*: None (optional for :class:`matplotlib.cm.ScalarMappable`) * *cmap*: None (optional for :class:`matplotlib.cm.ScalarMappable`) *offsets* and *transOffset* are used to translate the patch after rendering (default no offsets) If any of *edgecolors*, *facecolors*, *linewidths*, *antialiaseds* are None, they default to their :data:`matplotlib.rcParams` patch setting, in sequence form. )r c @ s4 e Zd ZdZdZdd� Zd dd�Zejdd � �Z d S ) �_CollectionWithSizeszA Base class for collections that have an array of sizes. � �?c C s | j S )z� Returns the sizes of the elements in the collection. The value represents the 'area' of the element. Returns ------- sizes : array The 'area' of each element. )�_sizesrU rQ rQ rR � get_sizes; s z _CollectionWithSizes.get_sizes� R@c C s� |dkr"t �g �| _t �d�| _nzt �|�| _t �t| j�ddf�| _t �| j�| d | j }|| jdd�ddf< || jdd�ddf< d| jdd�ddf< d | _ dS ) aF Set the sizes of each member of the collection. Parameters ---------- sizes : ndarray or None The size to set for each element of the collection. The value is the 'area' of the element. dpi : float The dpi of the canvas. Defaults to 72.0. Nr r r� r r r� r T) r< r� r� r� rY r� r= rp �sqrt�_factorr� )rF �sizes�dpiZscalerQ rQ rR � set_sizesG s z _CollectionWithSizes.set_sizesc C s" | � | j| jj� t�| |� d S rS )r� r� �figurer� r r� ry rQ rQ rR r� _ s z_CollectionWithSizes.drawN)r� ) r� r� r� r� r� r� r� r r� r� rQ rQ rQ rR r� 5 s r� c @ sF e Zd ZdZejddd��Zdd� Zdd� Zd d dd d � fd d�Z dS )�PathCollectionz� This is the most basic :class:`Collection` subclass. A :class:`PathCollection` is e.g. created by a :meth:`~.Axes.scatter` plot. Nc K s, t j| f|� | �|� | �|� d| _dS )zs *paths* is a sequence of :class:`matplotlib.path.Path` instances. %(Collection)s TN)r r# rX r� r� )rF ru r� rP rQ rQ rR r# j s zPathCollection.__init__c C s || _ d| _d S �NT)rE r� )rF ru rQ rQ rR rX x s zPathCollection.set_pathsc C s | j S rS rT rU rQ rQ rR rV | s zPathCollection.get_pathsr �autoc C s | S rS rQ )r� rQ rQ rR �<lambda>� � zPathCollection.<lambda>c K s� g }g }| � � dk }|dkr.tjjddd�}nt|t�rDtj�|�}|�� |dkr�|sjt� d� ||fS t � | � � �} |� dtj d �} n4|d kr�t � | �� �} |� d d �} ntd |� d ���|�|| ��� || ��� � |dkr�d}t| �|kr�d}|dk�r| } || �} n�|dk�r$| � � }n|d k�r6| �� }t|tjj��rL|}nHt �|��rftj�|�}n.t|�}tjj||d ddddddddgd�}|�||��� ||��� �} | ||��� k| ||��� k@ }| | } t �|�� |�� d�}t �| ||�|�} t | � � d | � � d�}|� |� t | | �D ]�\}}|dk�rP| �!| �"|��} n&|d k�rvt �#|�} t �$| d ��rv�q,t%j&dgdgfd | | | �'� d d �|��}|�(|� t)|d ��r�|�*| � ||�}|�(|� �q,||fS ) a� Creates legend handles and labels for a PathCollection. This is useful for obtaining a legend for a :meth:`~.Axes.scatter` plot. E.g.:: scatter = plt.scatter([1,2,3], [4,5,6], c=[7,2,3]) plt.legend(*scatter.legend_elements()) Also see the :ref:`automatedlegendcreation` example. Parameters ---------- prop : string, optional, default *"colors"* Can be *"colors"* or *"sizes"*. In case of *"colors"*, the legend handles will show the different colors of the collection. In case of "sizes", the legend will show the different sizes. num : int, None, "auto" (default), array-like, or `~.ticker.Locator`, optional Target number of elements to create. If None, use all unique elements of the mappable array. If an integer, target to use *num* elements in the normed range. If *"auto"*, try to determine which option better suits the nature of the data. The number of created elements may slightly deviate from *num* due to a `~.ticker.Locator` being used to find useful locations. If a list or array, use exactly those elements for the legend. Finally, a `~.ticker.Locator` can be provided. fmt : string, `~matplotlib.ticker.Formatter`, or None (default) The format or formatter to use for the labels. If a string must be a valid input for a `~.StrMethodFormatter`. If None (the default), use a `~.ScalarFormatter`. func : function, default *lambda x: x* Function to calculate the labels. Often the size (or color) argument to :meth:`~.Axes.scatter` will have been pre-processed by the user using a function *s = f(x)* to make the markers visible; e.g. *size = np.log10(x)*. Providing the inverse of this function here allows that pre-processing to be inverted, so that the legend labels have the correct values; e.g. *func = np.exp(x, 10)*. kwargs : further parameters Allowed kwargs are *color* and *size*. E.g. it may be useful to set the color of the markers if *prop="sizes"* is used; similarly to set the size of the markers if *prop="colors"* is used. Any further parameters are passed onto the `.Line2D` instance. This may be useful to e.g. specify a different *markeredgecolor* or *alpha* for the legend handles. Returns ------- tuple (handles, labels) with *handles* being a list of `.Line2D` objects and *labels* a matching list of strings. NFT)Z useOffsetZ useMathTextr zfCollection without array used. Make sure to specify the values to be colormapped via the `c` argument.r� zlines.markersizer� �color�kz?Valid values for `prop` are 'colors' or 'sizes'. You supplied 'z ' instead.r� � r r g @r � � � � )ZnbinsZ min_n_ticksZsteps� r )Zmarkeredgewidthr� g � )r r� ZmsZmarker�set_locs)+Z get_arrayr, ZtickerZScalarFormatterr\ r� ZStrMethodFormatterZcreate_dummy_axis�warnings�warnr< �unique�popr- r� r� Z set_bounds�min�maxrp ZLocator�iterableZ FixedLocator�intZ MaxNLocatorZ tick_valuesZlinspaceZinterpr� �get_linewidthsZ get_alpharD r� rJ rI r� Ziscloser� ZLine2DrV r� r] r )rF ZpropZnumZfmt�funcrP Zhandles�labelsZhasarray�ur� r� �valuesZ label_valuesZarrZlocZcondZxarr�kw�valZlab�h�lrQ rQ rR �legend_elements s� 6 � � � �� z PathCollection.legend_elements)N) r� r� r� r� r �dedent_interpdr# rX rV r rQ rQ rQ rR r� e s �r� c @ s2 e Zd Zejd dd��Zd dd�ZeZdd� ZdS ) �PolyCollectionNTc K s. t j| f|� | �|� | �||� d| _dS )a� *verts* is a sequence of ( *verts0*, *verts1*, ...) where *verts_i* is a sequence of *xy* tuples of vertices, or an equivalent :mod:`numpy` array of shape (*nv*, 2). *sizes* is *None* (default) or a sequence of floats that scale the corresponding *verts_i*. The scaling is applied before the Artist master transform; if the latter is an identity transform, then the overall scaling is such that if *verts_i* specify a unit square, then *sizes_i* is the area of that square in points^2. If len(*sizes*) < *nv*, the additional values will be taken cyclically from the array. *closed*, when *True*, will explicitly close the polygon. %(Collection)s TN)r r# r� � set_vertsr� )rF �vertsr� �closedrP rQ rQ rR r# s zPolyCollection.__init__c C s t |tjj�r |�t��tj�}|r�g | _|D ]�}t |�r�t |tjj�rbtj� ||dd� g�}n t� |�}t� ||dd� g�}tj |j d tjjd�}tjj|dd�< tjj|d< tjj|d< | j�t�||�� q.| j�t�|�� q.ndd� |D �| _d| _dS ) z8This allows one to delay initialization of the vertices.r r )ZdtypeN���c S s g | ]}t �|��qS rQ �rq r� )rc �xyrQ rQ rR rg / s z,PolyCollection.set_verts.<locals>.<listcomp>T)r\ r< rl rm ZastyperA rn ro rE rp � concatenater� r� rB rq r� Z code_typeZLINETOZMOVETOZ CLOSEPOLYr� r� )rF r r r r� rQ rQ rR r s$ zPolyCollection.set_vertsc C sl t |�t |�krtd��g | _t||�D ]8\}}t |�rN| j�t�||�� q(| j�t�|�� q(d| _dS )z7This allows one to initialize vertices with path codes.zB'codes' must be a 1D list or array with the same length of 'verts'TN)rp r� rE r� r� rq r� r� )rF r r� r ZcdsrQ rQ rR �set_verts_and_codes4 s z"PolyCollection.set_verts_and_codes)NT)T) r� r� r� r r r# r rX r rQ rQ rQ rR r � s r c @ s* e Zd ZdZejdd� �Zedd� �ZdS )�BrokenBarHCollectionz] A collection of horizontal bars spanning *yrange* with a sequence of *xranges*. c s8 |\�}�| � � �fdd�|D �}t j| |f|� dS )z� *xranges* sequence of (*xmin*, *xwidth*) *yrange* *ymin*, *ywidth* %(Collection)s c s: g | ]2\}}|�f|� f|| � f|| �f|�fg�qS rQ rQ )rc ZxminZxwidth��ymax�yminrQ rR rg T s � �z1BrokenBarHCollection.__init__.<locals>.<listcomp>N)r r# )rF �xrangesZyrangerP Zywidthr rQ r rR r# G s �z BrokenBarHCollection.__init__c K sf g }t �|�D ]<\}}| ||� }t|�s,q|�|d |d |d f� qt|||| gf|�} | S )a( Create a BrokenBarHCollection to plot horizontal bars from over the regions in *x* where *where* is True. The bars range on the y-axis from *ymin* to *ymax* A :class:`BrokenBarHCollection` is returned. *kwargs* are passed on to the collection. r r )r Zcontiguous_regionsrp r� r ) r� r! r �whererP r" Zind0Zind1ZxsliceZ collectionrQ rQ rR � span_where[ s ��z BrokenBarHCollection.span_whereN) r� r� r� r� r r r# r� r$ rQ rQ rQ rR r B s r c @ sP e Zd ZdZejjZej d Z e j ddd��Z dd� Zd d � Zejd d � �Zd S )�RegularPolyCollectionz6Draw a collection of regular polygons with *numsides*.� �r �r c K sD t j| f|� | �|� || _| �|�g| _|| _| �t� � � dS )aX *numsides* the number of sides of the polygon *rotation* the rotation of the polygon in radians *sizes* gives the area of the circle circumscribing the regular polygon in points^2 %(Collection)s Example: see :doc:`/gallery/event_handling/lasso_demo` for a complete example:: offsets = np.random.rand(20,2) facecolors = [cm.jet(x) for x in np.random.rand(20)] black = (0,0,0,1) collection = RegularPolyCollection( numsides=5, # a pentagon rotation=0, sizes=(50,), facecolors=facecolors, edgecolors=(black,), linewidths=(1,), offsets=offsets, transOffset=ax.transData, ) N) r r# r� � _numsides�_path_generatorrE � _rotation� set_transformr rx )rF ZnumsidesZrotationr� rP rQ rQ rR r# w s $ z RegularPolyCollection.__init__c C s | j S rS )r( rU rQ rQ rR � get_numsides� s z"RegularPolyCollection.get_numsidesc C s | j S rS )r* rU rQ rQ rR � get_rotation� s z"RegularPolyCollection.get_rotationc s8 � � � j� jj� � fdd�� jD �� _t�� |� d S )Nc s$ g | ] }t �|��� j ��� �qS rQ )r r� �rotater* � get_matrixr� rU rQ rR rg � s �z.RegularPolyCollection.draw.<locals>.<listcomp>)r� r� r� r� rY r r� ry rQ rU rR r� � s �zRegularPolyCollection.drawN)r r' )r� r� r� r� rq r� Zunit_regular_polygonr) r< �pir� r r r# r, r- r r� r� rQ rQ rQ rR r% q s � *r% c @ s e Zd ZdZejjZdS )�StarPolygonCollectionz:Draw a collection of regular stars with *numsides* points.N)r� r� r� r� rq r� Zunit_regular_starr) rQ rQ rQ rR r1 � s r1 c @ s e Zd ZdZejjZdS )�AsteriskPolygonCollectionz>Draw a collection of regular asterisks with *numsides* points.N)r� r� r� r� rq r� Zunit_regular_asteriskr) rQ rQ rQ rR r2 � s r2 c @ sR e Zd ZdZdZddd �Zd d � ZeZeZd d � Z dd� Z dd� Z dd� Z e Z dS )�LineCollectiona All parameters must be sequences or scalars; if scalars, they will be converted to sequences. The property of the ith line segment is:: prop[i % len(props)] i.e., the properties cycle if the ``len`` of props is less than the number of segments. TNr r� r r� c K s| |dkrt jd }|dkr&t jd f}|dkr:t jd f}t�|�}tj| f|| ||||||| | | d� | �� | �|� dS )a� Parameters ---------- segments A sequence of (*line0*, *line1*, *line2*), where:: linen = (x0, y0), (x1, y1), ... (xm, ym) or the equivalent numpy array with two columns. Each line can be a different length. colors : sequence, optional A sequence of RGBA tuples (e.g., arbitrary color strings, etc, not allowed). antialiaseds : sequence, optional A sequence of ones or zeros. linestyles : string, tuple, optional Either one of [ 'solid' | 'dashed' | 'dashdot' | 'dotted' ], or a dash tuple. The dash tuple is:: (offset, onoffseq) where ``onoffseq`` is an even length tuple of on and off ink in points. norm : Normalize, optional `~.colors.Normalize` instance. cmap : string or Colormap, optional Colormap name or `~.colors.Colormap` instance. pickradius : float, optional The tolerance in points for mouse clicks picking a line. Default is 5 pt. zorder : int, optional zorder of the LineCollection. Default is 2. facecolors : optional The facecolors of the LineCollection. Default is 'none'. Setting to a value other than 'none' will lead to a filled polygon being drawn between points on each line. Notes ----- If *linewidths*, *colors*, or *antialiaseds* is None, they default to their rcParams setting, in sequence form. If *offsets* and *transOffset* are not None, then *offsets* are transformed by *transOffset* and applied after the segments have been transformed to display coordinates. If *offsets* is not None but *transOffset* is None, then the *offsets* are added to the segments before any transformation. In this case, a single offset can be specified as:: offsets=(xo,yo) and this value will be added cumulatively to each successive segment, so as to produce a set of successively offset curves. The use of :class:`~matplotlib.cm.ScalarMappable` is optional. If the :class:`~matplotlib.cm.ScalarMappable` array :attr:`~matplotlib.cm.ScalarMappable._A` is not None (i.e., a call to :meth:`~matplotlib.cm.ScalarMappable.set_array` has been made), at draw time a call to scalar mappable will be made to set the colors. Nz lines.colorr� zlines.antialiased) r r r r r rG rH rI rJ rK rO )r, r- r* r� r r# � set_segments)rF �segmentsr r r r rG rH rI rJ rK rO r rP rQ rQ rR r# � s2 S �� �zLineCollection.__init__c C sl |d kr d S g }|D ](}t |tjj�s2t�|t�}|�|� q| jd k rR| �|�}dd� |D �| _ d| _ d S )Nc S s g | ]}t �|��qS rQ r )rc Z_segrQ rQ rR rg D s z/LineCollection.set_segments.<locals>.<listcomp>T) r\ r< rl rm r� rA r� r? � _add_offsetsrE r� )rF r5 Z _segmentsZsegrQ rQ rR r4 7 s zLineCollection.set_segmentsc C s: g }| j D ]*}dd� |�� D �}t�|�}|�|� q |S )z� Returns ------- segments : list List of segments in the LineCollection. Each list item contains an array of vertices. c S s g | ] \}}|�qS rQ rQ )rc Zvertex�_rQ rQ rR rg U s z/LineCollection.get_segments.<locals>.<listcomp>)rE Z iter_segmentsr< r� r� )rF r5 r r} rQ rQ rR � get_segmentsJ s zLineCollection.get_segmentsc C sz | j }t|�}|jd }|dkrDt|�D ]}|| || ||< q(n2t|�D ](}|| }|| |||d � ||< qL|S )Nr r )r? rp rB �range)rF ZsegsrG ZNsegsZNoffs�i�iorQ rQ rR r6 [ s zLineCollection._add_offsetsc C s | � |� d| _dS )a@ Set the color(s) of the LineCollection. Parameters ---------- c : color or list of colors Matplotlib color argument (all patches have same color), or a sequence or rgba tuples; if it is a sequence the patches will cycle through the sequence. TN)r0 r� r� rQ rQ rR r� h s zLineCollection.set_colorc C s | j S rS )r� rU rQ rQ rR � get_colorv s zLineCollection.get_color) NNNr NNNNr� r r� )r� r� r� r� r� r# r4 r rX r8 r6 r� r< � get_colorsrQ rQ rQ rR r3 � s, � m r3 c s� e Zd ZdZdZd%dd�Zd d � Zd d � Zd d� Ze Z Z dd� Z dd� Z dd� Z d&dd�Zdd� Zdd� Zdd � Zd d � Z� fd d �Z� fd!d"�Zd#d$� Z� ZS )'�EventCollectiona A collection of discrete events. The events are given by a 1-dimensional array, usually the position of something along an axis, such as time or length. They do not have an amplitude and are displayed as vertical or horizontal parallel bars. TNr r r c s |dkrt d��tj|dd�}||d ||d f� |jdkrFg } n�|jdkrZt d��n�|dksz|�� d ksz|�� d kr�|�� � fd d �|D �} d| _n@|�� d kr�|�� � fdd �|D �} d| _ntj d d g|d� t j | | f||||d�| �� || _ || _ dS )a Parameters ---------- positions : 1D array-like object Each value is an event. orientation : {None, 'horizontal', 'vertical'}, optional The orientation of the **collection** (the event bars are along the orthogonal direction). Defaults to 'horizontal' if not specified or None. lineoffset : scalar, optional, default: 0 The offset of the center of the markers from the origin, in the direction orthogonal to *orientation*. linelength : scalar, optional, default: 1 The total height of the marker (i.e. the marker stretches from ``lineoffset - linelength/2`` to ``lineoffset + linelength/2``). linewidth : scalar or None, optional, default: None If it is None, defaults to its rcParams setting, in sequence form. color : color, sequence of colors or None, optional, default: None If it is None, defaults to its rcParams setting, in sequence form. linestyle : str or tuple, optional, default: 'solid' Valid strings are ['solid', 'dashed', 'dashdot', 'dotted', '-', '--', '-.', ':']. Dash tuples should be of the form:: (offset, onoffseq), where *onoffseq* is an even length tuple of on and off ink in points. antialiased : {None, 1, 2}, optional If it is None, defaults to its rcParams setting, in sequence form. **kwargs : optional Other keyword arguments are line collection properties. See :class:`~matplotlib.collections.LineCollection` for a list of the valid properties. Examples -------- .. plot:: gallery/lines_bars_and_markers/eventcollection_demo.py Nz&positions must be an array-like objectT)�copy� @r r z:positions cannot be an array with more than one dimension.r� � horizontalc s g | ]� � fd d��D ��qS )c s g | ] }� |f�qS rQ rQ �rc Zcoord2�Zcoord1rQ rR rg � s �7EventCollection.__init__.<locals>.<listcomp>.<listcomp>rQ �rc ��segmentrC rR rg � s �z,EventCollection.__init__.<locals>.<listcomp>�verticalc s g | ]� � fd d��D ��qS )c s g | ] }|� f�qS rQ rQ rB rC rQ rR rg � s rD rQ rE rF rC rR rg � s �F�� orientation)r r r r )r� r< r� r� r� r� �sort�_is_horizontalr r� r3 r# � _linelength� _lineoffset) rF � positionsrJ � lineoffset� linelengthr r� r r rP r5 rQ rF rR r# � sN : � � � � ����zEventCollection.__init__c s. | � � }| �� rdnd� � fdd�| � � D �S )zW return an array containing the floating-point values of the positions r r c s g | ]}|d � f �qS )r rQ )rc rG ��posrQ rR rg � s z1EventCollection.get_positions.<locals>.<listcomp>)r8 � is_horizontal)rF r5 rQ rR rR � get_positions� s z EventCollection.get_positionsc s� |dks t |d�r,t|�dkr,| �g � dS | �� }| �� }||d ||d f� t�|�}|�� | �� r�� fdd�|D �}n� fdd�|D �}| �|� dS )zH set the positions of the events to the specified value Nrp r r@ c s g | ]� � fd d��D ��qS )c s g | ] }� |f�qS rQ rQ rB rC rQ rR rg � s �<EventCollection.set_positions.<locals>.<listcomp>.<listcomp>rQ rE rF rC rR rg � s �z1EventCollection.set_positions.<locals>.<listcomp>c s g | ]� � fd d��D ��qS )c s g | ] }|� f�qS rQ rQ rB rC rQ rR rg s rV rQ rE rF rC rR rg s �) r] rp r4 �get_lineoffset�get_linelengthr< r@ rK rT )rF rO rP rQ r5 rQ rF rR � set_positions� s( � � � �z EventCollection.set_positionsc C sL |dks t |d�r"t|�dkr"dS | �� }t�|t�|�g�}| �|� dS )zC add one or more events at the specified positions Nrp r )r] rp rU r< �hstackr@ rY )rF ZpositionrO rQ rQ rR � add_positions s �z EventCollection.add_positionsc C s | j S )zN True if the eventcollection is horizontal, False if vertical )rL rU rQ rQ rR rT s z EventCollection.is_horizontalc C s | � � r dS dS )zf get the orientation of the event line, may be: [ 'horizontal' | 'vertical' ] rA rH )rT rU rQ rQ rR �get_orientation s z EventCollection.get_orientationc C sH | � � }t|�D ]\}}t�|�||< q| �|� | �� | _d| _dS )zu switch the orientation of the event line, either from vertical to horizontal or vice versus TN)r8 � enumerater< Zfliplrr4 rT rL r� )rF r5 r: rG rQ rQ rR �switch_orientation s z"EventCollection.switch_orientationc C sf |dks |� � dks |� � dkr&d}n$|� � dkr8d}ntjddg|d� || �� krZdS | �� dS )z� set the orientation of the event line [ 'horizontal' | 'vertical' | None ] defaults to 'horizontal' if not specified or None Nr� rA TrH FrI )r� r r� rT r^ )rF rJ rT rQ rQ rR �set_orientation* s � � z EventCollection.set_orientationc C s | j S )zE get the length of the lines used to mark each event )rM rU rQ rQ rR rX < s z EventCollection.get_linelengthc C sv || � � krdS | �� }| �� }| �� r,dnd}|D ],}||d |d|f< ||d |d|f< q4| �|� || _dS )zE set the length of the lines used to mark each event Nr r r@ )rX rW r8 rT r4 rM )rF rQ rP r5 rS rG rQ rQ rR �set_linelengthB s z EventCollection.set_linelengthc C s | j S )zE get the offset of the lines used to mark each event )rN rU rQ rQ rR rW Q s z EventCollection.get_lineoffsetc C sv || � � krdS | �� }| �� }| �� r,dnd}|D ],}||d |d|f< ||d |d|f< q4| �|� || _dS )zE set the offset of the lines used to mark each event Nr r r@ )rW rX r8 rT r4 rN )rF rP rQ r5 rS rG rQ rQ rR �set_lineoffsetW s z EventCollection.set_lineoffsetc s t t| ��� d S )z3Get the width of the lines used to mark each event.r ��superr> r� rU �r� rQ rR r� f s z EventCollection.get_linewidthc s t t| ��� S rS rb rU rd rQ rR r j s z EventCollection.get_linewidthsc C s | � � d S )zD get the color of the lines used to mark each event r )r= rU rQ rQ rR r< m s zEventCollection.get_color)Nr r NNr N)N)r� r� r� r� r� r# rU rY r[ Zextend_positionsZappend_positionsrT r\ r^ r_ rX r` rW ra r� r r< � __classcell__rQ rQ rd rR r> | s2 � _ r> c @ s( e Zd ZdZejd Zejdd� �Z dS )�CircleCollectionz-A collection of circles, drawn using splines.r& c K s8 t j| f|� | �|� | �t�� � tj�� g| _ dS )zf *sizes* Gives the area of the circle in points^2 %(Collection)s N) r r# r� r+ r rx rq r� � unit_circlerE )rF r� rP rQ rQ rR r# y s zCircleCollection.__init__N) r� r� r� r� r< r0 r� r r r# rQ rQ rQ rR rf t s rf c @ s6 e Zd ZdZejd dd��Zdd� Zej dd� �Z d S ) �EllipseCollectionz.A collection of ellipses, drawn using splines.�pointsc K sx t j| f|� dt�|��� | _dt�|��� | _t�|��� | _|| _ | � t � � � t� d�| _tj�� g| _dS )a@ Parameters ---------- widths : array-like The lengths of the first axes (e.g., major axis lengths). heights : array-like The lengths of second axes. angles : array-like The angles of the first axes, degrees CCW from the x-axis. units : {'points', 'inches', 'dots', 'width', 'height', 'x', 'y', 'xy'} The units in which majors and minors are given; 'width' and 'height' refer to the dimensions of the axes, while 'x' and 'y' refer to the *offsets* data units. 'xy' differs from all others in that the angle as plotted varies with the aspect ratio, and equals the specified angle only when the aspect ratio is unity. Hence it behaves the same as the :class:`~matplotlib.patches.Ellipse` with ``axes.transData`` as its transform. Other Parameters ---------------- **kwargs Additional kwargs inherited from the base :class:`Collection`. %(Collection)s g �?r N)r r# r< r� Zravel�_widths�_heightsZdeg2rad�_angles�_unitsr+ r rx r� rY rq r� rg rE )rF �widths�heightsZanglesZunitsrP rQ rQ rR r# � s zEllipseCollection.__init__c C s� | j }| j}| jdkr d}n�| jdkr8|jj|jj }n�| jdkrT|jj|jj }nn| jdkrf|j}n\| jdkr||jd }nF| jdkr�|jj}n2| jd kr�|jj}n | jd kr�d }ntd | j ��t � t | j �d d f�| _ | j | }| j| }t �| j�}t �| j�}|| | j dd�ddf< || | j dd�ddf< || | j dd�ddf< || | j dd�ddf< d | j dd�ddf< tj}| jdk�r�|j�� �� �� } d| dd�dd�f< | �|| �� dS )z0Calculate transforms immediately before drawing.r r r� r� Zinchesri r� r� r� Zdotsr� zunrecognized units: %sr Nr r )r^ r� rm Zbboxr� ZviewLimr� r� r� r< r= rp rj rY rk Zsinrl Zcosr r� rt rj r/ r? r+ ) rF ZaxZfigZscrn ro Z sin_angleZ cos_angleZ_affine�mrQ rQ rR �_set_transforms� sD z!EllipseCollection._set_transformsc C s | � � t�| |� d S rS )rq r r� ry rQ rQ rR r� � s zEllipseCollection.drawN)ri ) r� r� r� r� r r r# rq r r� r� rQ rQ rQ rR rh � s (*rh c @ s" e Zd ZdZddd�Zdd� ZdS ) �PatchCollectionz� A generic collection of patches. This makes it easier to assign a color map to a heterogeneous collection of patches. This also may improve plotting speed, since PatchCollection will draw faster than a large number of patches. Fc s� |rjdd� � � fdd�|D �|d< dd� |D �|d< dd� |D �|d < d d� |D �|d < d d� |D �|d < t j| f|� | �|� dS )a� *patches* a sequence of Patch objects. This list may include a heterogeneous assortment of different patch types. *match_original* If True, use the colors and linewidths of the original patches. If False, new colors may be assigned by providing the standard collection arguments, facecolor, edgecolor, linewidths, norm or cmap. If any of *edgecolors*, *facecolors*, *linewidths*, *antialiaseds* are None, they default to their :data:`matplotlib.rcParams` patch setting, in sequence form. The use of :class:`~matplotlib.cm.ScalarMappable` is optional. If the :class:`~matplotlib.cm.ScalarMappable` matrix _A is not None (i.e., a call to set_array has been made), at draw time a call to scalar mappable will be made to set the face colors. c S s | � � r| �� S ddddgS )Nr )r� r� )ZpatchrQ rQ rR �determine_facecolor s z5PatchCollection.__init__.<locals>.determine_facecolorc s g | ] }� |��qS rQ rQ rb �rs rQ rR rg s z,PatchCollection.__init__.<locals>.<listcomp>r c S s g | ] }|� � �qS rQ )r� rb rQ rQ rR rg s r c S s g | ] }|� � �qS rQ )r� rb rQ rQ rR rg s r c S s g | ] }|� � �qS rQ )r� rb rQ rQ rR rg s r c S s g | ] }|� � �qS rQ )Zget_antialiasedrb rQ rQ rR rg s r N)r r# rX )rF �patchesZmatch_originalrP rQ rt rR r# � s zPatchCollection.__init__c C s dd� |D �}|| _ d S )Nc S s g | ]}|� � �|�� ��qS rQ )rh Ztransform_pathZget_pathrb rQ rQ rR rg s �z-PatchCollection.set_paths.<locals>.<listcomp>rT )rF ru ru rQ rQ rR rX s �zPatchCollection.set_pathsN)F)r� r� r� r� r# rX rQ rQ rQ rR rr � s &rr c @ sB e Zd ZdZdd� Zdd� Zdd� Zedd � �Ze j d d � �Z d S ) �TriMeshz� Class for the efficient drawing of a triangular mesh using Gouraud shading. A triangular mesh is a `~matplotlib.tri.Triangulation` object. c K s^ t j| f|� || _d| _d| _tj�� | _t � |j � dd�|j � dd�f�}| j�|� d S )N�gouraudTr r )r r# �_triangulation�_shadingr) r rs �unit�_bboxr< rZ r� �reshaper� �update_from_data_xy)rF Z triangulationrP r rQ rQ rR r# s �zTriMesh.__init__c C s | j d kr| �� | j S rS �rE rX rU rQ rQ rR rV . s zTriMesh.get_pathsc C s | � | j�| _d S rS )�convert_mesh_to_pathsrx rE rU rQ rQ rR rX 3 s zTriMesh.set_pathsc C s4 | � � }tj| j| | j| fdd�}dd� |D �S )z� Converts a given mesh into a sequence of `~.Path` objects. This function is primarily of use to implementers of backends that do not directly support meshes. r �Zaxisc S s g | ]}t �|��qS rQ r r� rQ rQ rR rg @ s z1TriMesh.convert_mesh_to_paths.<locals>.<listcomp>)�get_masked_trianglesr< �stackr� r� )�tri� trianglesr rQ rQ rR r 6 s z TriMesh.convert_mesh_to_pathsc C s� | � � s d S |�| jj� | �� }| j}|�� }tj|j | |j | fdd�}| � � | j | }|� � }| �|� |�| �� d � |�||||�� � |�� |�| jj� d S )Nr r� r )r� r� r� r� rh rx r� r< r� r� r� r� r� r� r� r1 r� �draw_gouraud_trianglesrr r� r� )rF rz rf r� r� r r r� rQ rQ rR r� B s z TriMesh.drawN) r� r� r� r� r# rV rX r� r r r� r� rQ rQ rQ rR rv s rv c @ sT e Zd ZdZddd�Zdd� Zdd � Zd d � Zed d � �Z dd� Z e j dd� �Z dS )�QuadMesha� Class for the efficient drawing of a quadrilateral mesh. A quadrilateral mesh consists of a grid of vertices. The dimensions of this array are (*meshWidth* + 1, *meshHeight* + 1). Each vertex in the mesh has a different set of "mesh coordinates" representing its position in the topology of the mesh. For any values (*m*, *n*) such that 0 <= *m* <= *meshWidth* and 0 <= *n* <= *meshHeight*, the vertices at mesh coordinates (*m*, *n*), (*m*, *n* + 1), (*m* + 1, *n* + 1), and (*m* + 1, *n*) form one of the quadrilaterals in the mesh. There are thus (*meshWidth* * *meshHeight*) quadrilaterals in the mesh. The mesh need not be regular and the polygons need not be convex. A quadrilateral mesh is represented by a (2 x ((*meshWidth* + 1) * (*meshHeight* + 1))) numpy array *coordinates*, where each row is the *x* and *y* coordinates of one of the vertices. To define the function that maps from a data point to its corresponding color, use the :meth:`set_cmap` method. Each of these arrays is indexed in row-major order by the mesh coordinates of the vertex (or the mesh coordinates of the lower left vertex, in the case of the colors). For example, the first entry in *coordinates* is the coordinates of the vertex at mesh coordinates (0, 0), then the one at (0, 1), then at (0, 2) .. (0, meshWidth), (1, 0), (1, 1), and so on. *shading* may be 'flat', or 'gouraud' T�flatc K sz t j| f|� || _|| _t�|t��|d |d df�| _|| _ || _ t j � � | _| j�|�|d |d df�� d S )Nr r )r r# � _meshWidth� _meshHeightr< r� rA r| � _coordinates� _antialiasedry r rs rz r{ r} )rF � meshWidth� meshHeight� coordinatesr ZshadingrP rQ rQ rR r# y s � �zQuadMesh.__init__c C s | j d kr| �� | j S rS r~ rU rQ rQ rR rV � s zQuadMesh.get_pathsc C s | � | j| j| j�| _d| _d S r� )r r� r� r� rE r� rU rQ rQ rR rX � s �zQuadMesh.set_pathsc C s | � � | �| j�S rS )rh Ztransform_bboxr{ )rF rt rQ rQ rR rw � s zQuadMesh.get_datalimc C s� t |tjj�r|j}n|}tj|dd�dd�f |dd�dd�f |dd�dd�f |dd�dd�f |dd�dd�f fdd�}|�| | ddf�}dd� |D �S ) z� Converts a given mesh into a sequence of `~.Path` objects. This function is primarily of use to implementers of backends that do not directly support quadmeshes. Nr r r r� r� c S s g | ]}t �|��qS rQ r r� rQ rQ rR rg � s z2QuadMesh.convert_mesh_to_paths.<locals>.<listcomp>)r\ r< rl rm r� r r| )r� r� r� r� ri rQ rQ rR r � s ��z QuadMesh.convert_mesh_to_pathsc C s� t |tjj�r|j}n|}|dd�dd�f }|dd�dd�f }|dd�dd�f }|dd�dd�f }|| | | d } tj||| ||| ||| ||| f dd�} | �|| d ddf�} | �� �|d |d df�} | dd�dd�f } | dd�dd�f } | dd�dd�f }| dd�dd�f }| | | | d }tj| | || ||||||| |f dd�}|�|| d ddf�}| |fS ) z� Converts a given mesh into a sequence of triangles, each point with its own color. This is useful for experiments using `draw_gouraud_triangle`. Nr r g @r r� � r )r\ r< rl rm r� r r| r� )rF r� r� r� rd Zp_aZp_bZp_cZp_dZp_centerr� r� Zc_aZc_bZc_cZc_dZc_centerr rQ rQ rR �convert_mesh_to_triangles� sb �� ��z"QuadMesh.convert_mesh_to_trianglesc C s� | � � s d S |�| jj| �� � | �� }| �� }| j}| �� r�t | j�r�| � | jd d �df �}| � | jd d �df �}t � ||g�}| �� |js�| j�d�}|�|�}|�| jj�}t�� }n| j}|js�|�|�}|�� }|�� }| �|� |�| �� d � | j dk�r<| � | j | j |�\} } |� || | |�!� � n.|�"||�!� | j | j |||| �#� | j$| �%� � |�&� |�'| jj� d| _(d S )Nr r )r r rw F))r� r� r� r� r� rh r` r> r| rp r~ r r< r� r� ri r� r| rf rB r rx rk rj r� r� r1 r� ry r� r� r� r� rr Zdraw_quad_meshr� r� Zget_edgecolorsr� r� r� ) rF rz rf rH rG r� r� r� r� r� r rQ rQ rR r� � sf � � �z QuadMesh.drawN)Tr� )r� r� r� r� r# rV rX rw r� r r� r r� r� rQ rQ rQ rR r� Z s � *r� ) r� rv r r r% r� r1 rr rf r )r3 )-r� r� Znumbersr Znumpyr< Z matplotlibr, r r r r r r r* r r r� r rq r r Z_define_aliasesr" r$ r ZinterpdrD r� r� r r r% r1 r2 r3 r> rf rh rr rv r� ZkwdocZpatchstrr� rQ rQ rQ rR �<module> sV ,� 0 C/A A y\7@ ,