m[c@`sdZddlmZmZmZmZddlZddlmZddl Z ddl m Z m Z ddlmZmZmZdefd YZd Zgd ZdS( u A module for dealing with the polylines used throughout Matplotlib. The primary class for polyline handling in Matplotlib is `Path`. Almost all vector drawing makes use of `Path`\s somewhere in the drawing pipeline. Whilst a `Path` instance itself cannot be drawn, some `.Artist` subclasses, such as `.PathPatch` and `.PathCollection`, can be used for convenient `Path` visualisation. i(tabsolute_importtdivisiontprint_functiontunicode_literalsN(tWeakValueDictionaryi(t_pathtrcParams(t_to_unmasked_float_arraytsimple_linear_interpolationtmaxdicttPathc B`s2eZdZdZdZdZdZdZdZide6de6de6de6de6de6Z e j Z d5deedZed5dZd Zed Zejd Zed Zejd ZedZejdZedZedZejdZedZdZeZd5dZeZedZedZ dZ!dZ"d5e#d5edd5e#d5dZ$d5ed5eeeded5d Z%dZ&d5ddZ'd5dd Z(d5d!Z)d5d"Z*e#d#Z+e#d$Z,d%Z-d5dde#d&Z.d5Z/ed'Z0e1Z2ed(Z3e1Z4ed)d*Z5ed+Z6d5Z7ed,Z8ed6ded-Z9d5Z:ed.Z;ed5ed/Z<ed5d0Z=e>d1Z?ed2d3Z@e#d4ZARS(7u :class:`Path` represents a series of possibly disconnected, possibly closed, line and curve segments. The underlying storage is made up of two parallel numpy arrays: - *vertices*: an Nx2 float array of vertices - *codes*: an N-length uint8 array of vertex types These two arrays always have the same length in the first dimension. For example, to represent a cubic curve, you must provide three vertices as well as three codes ``CURVE3``. The code types are: - ``STOP`` : 1 vertex (ignored) A marker for the end of the entire path (currently not required and ignored) - ``MOVETO`` : 1 vertex Pick up the pen and move to the given vertex. - ``LINETO`` : 1 vertex Draw a line from the current position to the given vertex. - ``CURVE3`` : 1 control point, 1 endpoint Draw a quadratic Bezier curve from the current position, with the given control point, to the given end point. - ``CURVE4`` : 2 control points, 1 endpoint Draw a cubic Bezier curve from the current position, with the given control points, to the given end point. - ``CLOSEPOLY`` : 1 vertex (ignored) Draw a line segment to the start point of the current polyline. Users of Path objects should not access the vertices and codes arrays directly. Instead, they should use :meth:`iter_segments` or :meth:`cleaned` to get the vertex/code pairs. This is important, since many :class:`Path` objects, as an optimization, do not store a *codes* at all, but have a default one provided for them by :meth:`iter_segments`. Some behavior of Path objects can be controlled by rcParams. See the rcParams whose keys contain 'path.'. .. note:: The vertices and codes arrays should be treated as immutable -- there are a number of optimizations and assumptions made up front in the constructor that will not change when the data changes. iiiiiiOcC`st|}|jdks.|jddkr=tdn|d k rtj||j}|jdkst|t|krtdnt|r"|d|j kr"tdj |j q"nQ|r"tj t|d|j}|j |d<|j |dd+|j |d`_. grSl?g?ggg?R iiiR&(RtsqrttarraytfloattCURVE4RRR ( R.RRpR&tMAGICtSQRTHALFtMAGIC45R#R$((s.lib/python2.7/site-packages/matplotlib/path.pyRsD                    cC`s4|jd kr-d}tjd}||}tjddg|dg||| |g|| g||| |gd| gddgd|g||||g||g||||g|dgddgddggt}|jtjd}|j|d<|j |d<|||d t |_n|jS( u} Return a :class:`Path` of the right half of a unit circle. The circle is approximated using cubic Bezier curves. This uses 4 splines around the circle using the approach presented here: Lancaster, Don. `Approximating a Circle or an Ellipse Using Four Bezier Cubic Splines `_. grSl?g?ggg?iiiR&N( t_unit_circle_righthalfRRRRRRR@RRR (R.RRRR#R$((s.lib/python2.7/site-packages/matplotlib/path.pytunit_circle_righthalfs2               cC`s~tjd}|}|dtj||d}||krW||krW|d7}ntj||g\}}|dkrtdtj|||}n|dkrtdn|||}tjd|} tj |tj dd| | dd} tj |||dt } tj | } tj | } | d }| d }| }|}| d}| d}| }|}|r/|d d }tj|dft}|jtj|f|j}|d |d g|d<|j|jg|d d+|j|jg|d )d}|d}nv|d d}tj|dft}|jtj|f|j}|d |d g|d <|j|d *theta1* + 360, the arc will be from *theta1* to *theta2* - 360 and not a full circle plus some extra overlap. If *n* is provided, it is the number of spline segments to make. If *n* is not provided, the number of spline segments is determined based on the delta between *theta1* and *theta2*. Masionobe, L. 2003. `Drawing an elliptical arc using polylines, quadratic or cubic Bezier curves `_. g?ihiiun must be >= 1 or Noneg@g@iiiiiR&N(RRtfloortdeg2radRRAtceilRttanRRtlinspaceR RR?RRR@RRRRR(R.ttheta1ttheta2tntis_wedgethalfpiteta1teta2tdetatttalphaRtcos_etatsin_etatxAtyAtxA_dottyA_dottxBtyBtxB_dottyB_dottlengthR#R$t vertex_offsettend((s.lib/python2.7/site-packages/matplotlib/path.pytarcLs^   $ 0      !!%%cC`s|j|||tS(u( Return a wedge of the unit circle from angle *theta1* to angle *theta2* (in degrees). *theta2* is unwrapped to produce the shortest wedge within 360 degrees. That is, if *theta2* > *theta1* + 360, the wedge will be from *theta1* to *theta2* - 360 and not a full circle plus some extra overlap. If *n* is provided, it is the number of spline segments to make. If *n* is not provided, the number of spline segments is determined based on the delta between *theta1* and *theta2*. (RR (R.RRR((s.lib/python2.7/site-packages/matplotlib/path.pytwedgesiicC`snddlm}|dkr dS|jj||f}|dk rH|S|||}||j||f<|S(u Given a hatch specifier, *hatchpattern*, generates a Path that can be used in a repeated hatching pattern. *density* is the number of lines per unit square. i(tget_pathN(tmatplotlib.hatchRRt _hatch_dictR(R.t hatchpatterntdensityRt hatch_path((s.lib/python2.7/site-packages/matplotlib/path.pythatchs  cC`sAtj|||}g|D]}t|^q}|j|S(u. Clip the path to the given bounding box. The path must be made up of one or more closed polygons. This algorithm will not behave correctly for unclosed paths. If *inside* is `True`, clip to the inside of the box, otherwise to the outside of the box. (Rtclip_path_to_rectR RT(R"RtinsideR/tpolytpaths((s.lib/python2.7/site-packages/matplotlib/path.pyt clip_to_bboxs N(gg(Bt__name__t __module__t__doc__RaRRtCURVE3RRR`Rtuint8RRRR't classmethodR2RtpropertyR#tsetterR$R+R9R*R&R;R:R>tdeepcopyRJRTRURVR RgR_RjRqRvRxR|RRRRRRRRRRRRRRRRRRRR RRR(((s.lib/python2.7/site-packages/matplotlib/path.pyR s6   >!        F      ,    F.N cC`s\ddlm}t|dkr1tdn|jtj||tj|||S(u Given a sequence of :class:`Path` objects, :class:`~matplotlib.transforms.Transform` objects and offsets, as found in a :class:`~matplotlib.collections.PathCollection`, returns the bounding box that encapsulates all of them. *master_transform* is a global transformation to apply to all paths *paths* is a sequence of :class:`Path` instances. *transforms* is a sequence of :class:`~matplotlib.transforms.Affine2D` instances. *offsets* is a sequence of (x, y) offsets (or an Nx2 array) *offset_transform* is a :class:`~matplotlib.transforms.Affine2D` to apply to the offsets before applying the offset to the path. The way that *paths*, *transforms* and *offsets* are combined follows the same method as for collections. Each is iterated over independently, so if you have 3 paths, 2 transforms and 1 offset, their combinations are as follows: (A, A, A), (B, B, A), (C, A, A) i(RyiuNo paths provided( RzRyRRt from_extentsRtget_path_collection_extentsRt atleast_3d(tmaster_transformRRztoffsetstoffset_transformRy((s.lib/python2.7/site-packages/matplotlib/path.pyRs  cC`s_ddlm}m}t|dkr7tdn|jtj|||g|S(ui Given a sequence of :class:`Path` objects and optional :class:`~matplotlib.transforms.Transform` objects, returns the bounding box that encapsulates all of them. *paths* is a sequence of :class:`Path` instances. *transforms* is an optional sequence of :class:`~matplotlib.transforms.Affine2D` instances to apply to each path. i(RytAffine2DiuNo paths provided(RzRyRRRRRR(RRzRyR((s.lib/python2.7/site-packages/matplotlib/path.pytget_paths_extentss  (Rt __future__RRRRtsixtweakrefRtnumpyRtRRtcbookRRR tobjectR RR(((s.lib/python2.7/site-packages/matplotlib/path.pyt s"   #