Ñò t,2Jc @s»dZddkZddklZddkZddklZddklZl Z l Z l Z l Z l Z lZddklZddklZdefd „ƒYZe Zd „Z dS( s2 Contains a class for managing paths (polylines). iÿÿÿÿN(tWeakValueDictionary(tma(t point_in_pathtget_path_extentstpoint_in_path_collectiontget_path_collection_extentst path_in_pathtpath_intersects_pathtconvert_path_to_polygons(tsimple_linear_interpolation(trcParamstPathcBs¯eZdZdZdZdZdZdZdZddddddgZ e i Z dd„Zd„ZeeƒZd „Zd „Zdd „Zd „Zdd „Zdd„Zdd„Zed„Zed„Zd„Zdddd„ZdZd„ZeeƒZe ƒZ!d„Z"ee"ƒZ"e ƒZ#dd„Z$ee$ƒZ$d„Z%ee%ƒZ%dZ&d„Z'ee'ƒZ'de(d„Z)ee)ƒZ)dd„Z*ee*ƒZ*RS(s~ :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` 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`. Note also that 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. iiiiiicCsKti|ƒo"|itiƒitiƒ}nti|tiƒ}|dj oPti||i ƒ}|i djpt ‚t |ƒt |ƒjpt ‚n|i djpt ‚|i ddjpt ‚tdo6t |ƒdjo#|djpti|tijƒ|_ti|ƒiƒ |_||_||_dS(s© Create a new path with the given vertices and codes. *vertices* is an Nx2 numpy float array, masked array or Python sequence. *codes* is an N-length numpy array or Python sequence of type :attr:`matplotlib.path.Path.code_type`. These two arrays must have the same length in the first dimension. If *codes* is None, *vertices* will be treated as a series of line segments. If *vertices* contains masked values, they will be converted to NaNs which are then handled correctly by the Agg PathIterator and other consumers of path data, such as :meth:`iter_segments`. iis path.simplifyi€N(Rt isMaskedArraytastypetnptfloat_tfilledtnantasarraytNonet code_typetndimtAssertionErrortlentshapeR tallR tLINETOtshould_simplifytisfinitet has_nonfinitetcodestvertices(tselfRR((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pyt__init__Os" $ ( c Gsìx%|D]}|idjpt‚qWg}|D]}|t|ƒq3~}t|ƒ}tig}|D]}||iql~ƒ}|i|dfƒt i ti |ƒ}d} x%|D]} t i || <| | 7} q¾Wt ||ƒS(s… (staticmethod) Make a compound path from a list of Path objects. Only polygons (not curves) are supported. iiN( RRRRtsumRtvstackRtreshapeR RtonestMOVETO( targstpt_[1]txtlengthst total_lengtht_[2]RRtitlength((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pytmake_compound_pathys' - cCsd|i|ifS(Ns Path(%s, %s)(RR(R ((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pyt__repr__scCs t|iƒS(N(RR(R ((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pyt__len__“sccsT|i}t|ƒpdS|i}t|ƒ}ti}|i}|i}|i}|i} |i } |dj o`|i oV|i d|Œ} x¾| D]5}|d|fVx|dD]} | |fVq¶Wq–Wn~|djo‰|i oL|} xr|D]7} ti| ƒiƒo| | fV|} q÷|} q÷WqP|d|fVx|dD]} | |fVqPWnèd}t}xØ||joÊ||}|| jog|fV|d7}qx|| jodS|t|ƒ}||||!iƒ}||ƒiƒp t}n7|o$|d |fV||fVt}n ||fV||7}qxWdS(s Iterates over all of the curve segments in the path. Each iteration returns a 2-tuple (*vertices*, *code*), where *vertices* is a sequence of 1 - 3 coordinate pairs, and *code* is one of the :class:`Path` codes. If *simplify* is provided, it must be a tuple (*width*, *height*) defining the size of the figure, in native units (e.g. pixels or points). Simplification implies both removing adjacent line segments that are very close to parallel, and removing line segments outside of the figure. The path will be simplified *only* if :attr:`should_simplify` is True, which is determined in the constructor by this criteria: - No curves - More than 128 vertices Niii(RRRRRt NUM_VERTICESR&Rt CLOSEPOLYtSTOPRRt to_polygonsRRtFalsetinttflattentTrue(R tsimplifyRRt len_verticesRR3R&RR4R5tpolygonstvt next_codeR.twas_nantcodet num_verticest curr_vertices((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pyt iter_segments–sh                         cCst|i|iƒ|iƒS(s/ Return a transformed copy of the path. .. seealso:: :class:`matplotlib.transforms.TransformedPath`: A specialized path class that will cache the transformed result and automatically update when the transform changes. (R t transformRR(R RE((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pyt transformedàs cCs8|dj o|iƒ}nt|d|d||ƒS(s® Returns *True* if the path contains the given point. If *transform* is not *None*, the path will be transformed before performing the test. iiN(RtfrozenR(R tpointRE((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pytcontains_pointìs cCs0|dj o|iƒ}nt|d||ƒS(s¹ Returns *True* if this path completely contains the given path. If *transform* is not *None*, the path will be transformed before performing the test. N(RRGR(R tpathRE((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pyt contains_path÷s cCs@ddkl}|dj o|iƒ}n|t||ƒƒS(s Returns the extents (*xmin*, *ymin*, *xmax*, *ymax*) of the path. Unlike computing the extents on the *vertices* alone, this algorithm will take into account the curves and deal with control points appropriately. iÿÿÿÿ(tBboxN(t transformsRLRRGR(R RERL((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pyt get_extentss  cCst|||ƒS(s Returns *True* if this path intersects another given path. *filled*, when True, treats the paths as if they were filled. That is, if one path completely encloses the other, :meth:`intersects_path` will return True. (R(R totherR((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pytintersects_pathscCsAddkl}|iƒi||ƒƒ}|i||ƒ}|S(s Returns *True* if this path intersects a given :class:`~matplotlib.transforms.Bbox`. *filled*, when True, treats the path as if it was filled. That is, if one path completely encloses the other, :meth:`intersects_path` will return True. iÿÿÿÿ(tBboxTransformTo(RMRQtunit_rectangleRFRP(R tbboxRRQt rectangletresult((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pytintersects_bboxs  cCs}t|i|ƒ}|i}|dj oBtitit|ƒd|dfƒ}||dd|…`_. grSlùÐ?gà?g@ggð¿gð?iiiÿÿÿÿN( t _unit_circleRRtsqrttarrayRtCURVE4R%R&R4R (R]tMAGICtSQRTHALFtMAGIC45RR((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pyt unit_circležsJ                      c Csë|tid9}|tid9}tid}tid}titi|ƒti|ƒƒ}titi|ƒti|ƒƒ}||ti|||ƒ8}||tijo"||tijo||7}n|djo%tdti|||ƒƒ}n|djot dƒ‚n|||} ti d| ƒ} ti| ƒti dd| | ƒdd} ti |||dt ƒ} ti| ƒ} ti| ƒ}| d }|d }| }|}| d}|d}| }|}|o£|d d }ti|dftiƒ}titi|ftiƒ}|d |d g|d`_. g€f@g@gà?iisn must be >= 1 or Noneg@g@iÿÿÿÿiiiiþÿÿÿN(RR`tarctan2RdRctfloorRR8tceilt ValueErrorttanRqtlinspaceR:tzerosRR RsR%RR&RR4(R]ttheta1ttheta2tntis_wedgettwopithalfpiteta1teta2tdetatttalphaRWtcos_etatsin_etatxAtyAtxA_dottyA_dottxBtyBtxB_dottyB_dotR/RRt vertex_offsettend((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pytarcÜsd  $$( % 0     !!%%cCs|i|||tƒS(sO (staticmethod) Returns a wedge of the unit circle from angle *theta1* to angle *theta2* (in degrees). 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*. (R–R:(R]RR€R((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pytwedge+s N(+t__name__t __module__t__doc__R5R&RtCURVE3RsR4R3Rtuint8RRR!R0t staticmethodR1R2RDRFRIRKRNR:RPRVRYR6R\RRt classmethodRR^RhRiRnRoRpRwR7R–R—(((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pyR sR0  *     J             ; L  cGsJddkl}t|dƒdjotdƒ‚n|it|ŒŒS(sp Given a sequence of :class:`Path` objects, returns the bounding box that encapsulates all of them. iÿÿÿÿ(RLiisNo paths provided(RMRLRR{t from_extentst_get_path_collection_extents(R'RL((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pyR8s(RštmathtweakrefRtnumpyRRtmatplotlib._pathRRRRRRRtmatplotlib.cbookR t matplotlibR tobjectR R (((s?P:\graphics\Tools\Python26\lib\site-packages\matplotlib\path.pyts  4ÿÿ(