�
�)�Uc@s�dZd
dl
Zd
dl
mZ
d
dlmZ
d
dlmZ
d
dlm	Z	
d
dl
Z
ye
Wn!ek
r�


d
dl
mZ
n
Xd
dlZd
dlmZ
d
d	lmZmZ
eZer�d
dl
Z
nejZd
ef
d��YZdef
d
��YZdef
d��YZdef
d��YZdef
d��YZdef
d��YZdef
d��YZdef
d��YZ de f
d��YZ!de f
d��YZ"def
d��YZ#d e f
d!��YZ$d"�Z%d#ef
d$��YZ&d%e f
d&��YZ'd'�Z(d(e f
d)��YZ)d*e f
d+��YZ*d,e*f
d-��YZ+d.e f
d/��YZ,d0e f
d1��YZ-d2ef
d3��YZ.d4d5e/d6�Z0d7�Z1d8�Z2e3d9d9d:d;�Z4dS(<s�
matplotlib includes a framework for arbitrary geometric
transformations that is used determine the final position of all
elements drawn on the canvas.

Transforms are composed into trees of :class:`TransformNode` objects
whose actual value depends on their children.  When the contents of
children change, their parents are automatically invalidated.  The
next time an invalidated transform is accessed, it is recomputed to
reflect those changes.  This invalidation/caching approach prevents
unnecessary recomputations of transforms, and contributes to better
interactive performance.

For example, here is a graph of the transform tree used to plot data
to the graph:

.. image:: ../_static/transforms.png

The framework can be used for both affine and non-affine
transformations.  However, for speed, we want use the backend
renderers to perform affine transformations whenever possible.
Therefore, it is possible to perform just the affine or non-affine
part of a transformation on a set of data.  The affine is always
assumed to occur after the non-affine.  For any transform::

  full transform == non-affine part + affine part

The backends are not expected to handle non-affine transformations
themselves.
i����N(
tma(
taffine_transform(
tinv(
tWeakKeyDictionary(
tSet(
tPath(tcount_bboxes_overlapping_bboxtupdate_path_extentst
TransformNodecBs�eZ
dZd
ZdZdZeeBZeZeZ	eZ
d�Zd�ZeZ
d�Zd�Zer�eZd�Zeje_nd	�Zer�gd
�
Zngd�
ZRS(sE

    :class:`TransformNode` is the base class for anything that
    participates in the transform tree and needs to invalidate its
    parents or be invalidated.  This includes classes that are not
    really transforms, such as bounding boxes, since some transforms
    depend on bounding boxes to compute their values.
    ii
ic

Cst�|_
d
|_dS(s7
        Creates a new :class:`TransformNode`.
        i
N(Rt_parentst_invalid(
tself((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt__init__Psc
Gstd
d�
�
dS(Ns+TransformNode instances can not be copied. s Consider using frozen() instead.(
tNotImplementedError(Rtargs((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt__copy__]s


c
Cs�|jr|j
p|j}
|j|
kr.d
St|j�
sJ|
|_d
S|g
}xYt|�
r�|j�}|j|
ks�|jrV|j|_|j|jj	��

qVqVWd
S(s�
        Invalidate this :class:`TransformNode` and all of its
        ancestors.  Should be called any time the transform changes.
        N(
t	is_affinetINVALID_AFFINEtINVALIDR
tlenR	tpoptpass_throughtextendtkeys(Rtvaluetstacktroot((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt
invalidatecs

	
	



c
Gs"x|
D]}d
|j
|<qWd
S(s�
        Set the children of the transform, to let the invalidation
        system know which transforms can invalidate this transform.
        Should be called from the constructor of any transforms that
        depend on other transforms.
        N(tNoneR	(Rtchildrentchild((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytset_children~s

c
Gs|j|
�
|
|_
dS(
N(t
_set_childrent	_children(RR((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s


c


Cs|S(
s

        Returns a frozen copy of this transform node.  The frozen copy
        will not update when its children change.  Useful for storing
        a previously known state of a transform where
        ``copy.deepcopy()`` might normally be used.
        ((
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytfrozen�scsIt����
��fd
���j
d�

�|�

�j
d�

dS(s�

            For debugging purposes.

            Writes the transform tree rooted at 'self' to a graphviz "dot"
            format file.  This file can be run through the "dot" utility
            to produce a graph of the transform tree.

            Affine transforms are marked in blue.  Bounding boxes are
            marked in yellow.

            *fobj*: A Python file-like object
            c
sa
|�krdS�j|�

i}
|j
j}|jrEd
|}n|�
kr^d|
d<nd|
d<d||
d<djg|
j�D]\}}d	||f^q��
}
�jd
t|�
|
f�

t|d�r]
x�|j	D]r}d}x3|j
j�D]"\}}||kr
|}Pq
q
W�jd
t|�
t|�
|f�

�|�

q�WndS(Ns[%s]tboldtstyletboxtshapes"%s"tlabelt
 s%s=%ss	%s [%s];
R!t
?s$%s -> %s [label="%s", fontsize=10];
(taddt	__class__t__name__R
tjointitemstwritethashthasattrR!t__dict__(RtpropsR'tkeytvalRtname(tfobjt	highlighttrecursetseen(sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR9�s4






	








8	







	
	
	

sdigraph G {
s}
N(tsetR/(RR7R8((R7R8R9R:sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytwrite_graphviz�s

	



c
CsdS(
N((RR7R8((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR<�s
(R,t
__module__t__doc__t_gidtINVALID_NON_AFFINERRtFalseRtis_bboxRRRt__deepcopy__RRtDEBUGR R"R<(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR6s*




	
			


			
1tBboxBasecBs�eZ
dZeZeZer6d
�Zee�
Znd�Z	e
je	_d�Zd�Zd�Z
ee
dOdOd�Zd�ZeedOdOd�Zd	�ZeedOdOd
�Zd�ZeedOdOd�Zd
�ZeedOdOd�Zd�ZeedOdOd�Zd�ZeedOdOd�Zd�ZeedOdOd�Zd�ZeedOdOd�Z d�Z!ee!dOdOd�Z"d�Z#ee#dOdOd�Z$d�Z%ee%dOdOd�Z&d�Z'ee'dOdOd�Z(d�Z)ee)dOdOd �Z*d!�Z+ee+dOdOd"�Z,d#�Z-ee-dOdOd$�Z.d%�Z/ee/dOdOd&�Z0d'�Z1ee1dOdOd(�Z2d)�Z3ee3dOdOd*�Z4d+�Z5d,�Z6d-�Z7d.�Z8d/�Z9d0�Z:d1�Z;d2�Z<d3�Z=d4�Z>d5�Z?i	dPd76dQd96dRd:6dSd<6dTd=6dUd>6dVd?6dWd@6dXdA6Z@dOdB�
ZAdC�ZBdOd;dD�ZCdE�ZDdF�ZEdG�ZFdH�ZGdI�ZHdJ�ZIdK�ZJdL�ZKdM�ZLedN��
ZMRS(Ys�

    This is the base class of all bounding boxes, and provides
    read-only access to its data.  A mutable bounding box is provided
    by the :class:`Bbox` class.

    The canonical representation is as two points, with no
    restrictions on their ordering.  Convenience properties are
    provided to get the left, bottom, right and top edges and width
    and height, but these are not stored explicity.
    c

Csrtj
|�
rtjd
�

ntj|�
}|d|ddks^|d|ddkrntjd�

ndS(	NsBbox bounds are a masked array.i
isSingular Bbox.(i
i(ii(i
i
(ii
(Rt
isMaskedArraytwarningstwarntnptasarray(
tpoints((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_check�s





c

Cst|j
�j��
S(
N(tBboxt
get_pointstcopy(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR"�s
c

Os
|j�S(
N(
RN(RRtkwargs((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt	__array__�s
c

Cs(t|j
�j��
d
d
ddgkS(sk
        Returns True if the :class:`Bbox` is the unit bounding box
        from (0, 0) to (1, 1).
        gg�?(tlistRNtflatten(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytis_unit�sc

Cs|j�dS(Ni(ii(
RN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_x0�s
s�
         (property) :attr:`x0` is the first of the pair of *x* coordinates that
         define the bounding box.  :attr:`x0` is not guaranteed to be
         less than :attr:`x1`.  If you require that, use :attr:`xmin`.c

Cs|j�dS(Nii
(ii
(
RN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_y0
s
s�
         (property) :attr:`y0` is the first of the pair of *y* coordinates that
         define the bounding box.  :attr:`y0` is not guaranteed to be
         less than :attr:`y1`.  If you require that, use :attr:`ymin`.c

Cs|j�dS(Ni
i(i
i(
RN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_x1
s
s�
         (property) :attr:`x1` is the second of the pair of *x* coordinates that
         define the bounding box.  :attr:`x1` is not guaranteed to be
         greater than :attr:`x0`.  If you require that, use :attr:`xmax`.c

Cs|j�dS(Ni
(i
i
(
RN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_y1
s
s�
         (property) :attr:`y1` is the second of the pair of *y* coordinates that
         define the bounding box.  :attr:`y1` is not guaranteed to be
         greater than :attr:`y0`.  If you require that, use :attr:`ymax`.c

Cs|j�d
S(Ni(
RN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_p0
s
s�
         (property) :attr:`p0` is the first pair of (*x*, *y*) coordinates that
         define the bounding box.  It is not guaranteed to be the bottom-left
         corner.  For that, use :attr:`min`.c

Cs|j�d
S(Ni
(
RN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_p1
s
s�
         (property) :attr:`p1` is the second pair of (*x*, *y*) coordinates that
         define the bounding box.  It is not guaranteed to be the top-right
         corner.  For that, use :attr:`max`.c

Cs t|j
�dd�d
f�
S(Ni(tminRN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt	_get_xmin#
s
sF
        (property) :attr:`xmin` is the left edge of the bounding box.c

Cs t|j
�dd�d
f�
S(Ni
(R[RN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt	_get_ymin(
s
sH
        (property) :attr:`ymin` is the bottom edge of the bounding box.c

Cs t|j
�dd�d
f�
S(Ni(tmaxRN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt	_get_xmax-
s
sG
        (property) :attr:`xmax` is the right edge of the bounding box.c

Cs t|j
�dd�d
f�
S(Ni
(R^RN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt	_get_ymax2
s
sE
        (property) :attr:`ymax` is the top edge of the bounding box.c

CsBt|j
�dd�d
f�
t|j
�dd�df�
gS(Nii
(R[RN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_min7
s

sV
        (property) :attr:`min` is the bottom-left corner of the bounding
        box.c

CsBt|j
�dd�d
f�
t|j
�dd�df�
gS(Nii
(R^RN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_max>
s

sL
        (property) :attr:`max` is the top-right corner of the bounding box.c

Cs|j�dd�d
fS(Ni(
RN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_intervalxD
s
s�
        (property) :attr:`intervalx` is the pair of *x* coordinates that define
        the bounding box. It is not guaranteed to be sorted from left to
        right.c

Cs|j�dd�d
fS(Ni
(
RN(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_intervalyK
s
s�
        (property) :attr:`intervaly` is the pair of *y* coordinates that define
        the bounding box.  It is not guaranteed to be sorted from bottom to
        top.c
Cs|j�}
|
d|
dS(Ni
i(i
i(ii(
RN(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt
_get_widthR
s

sj
        (property) The width of the bounding box.  It may be negative if
        :attr:`x1` < :attr:`x0`.c
Cs|j�}
|
d|
dS(Ni
i(i
i
(ii
(
RN(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_heightY
s

sk
        (property) The height of the bounding box.  It may be negative if
        :attr:`y1` < :attr:`y0`.c
Cs|j�}
|
d
|
dS(Ni
i(
RN(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt	_get_size`
s

s�
        (property) The width and height of the bounding box.  May be negative,
        in the same way as :attr:`width` and :attr:`height`.c
Cs6|j�j
�\}
}}}|
|||
||fS(
N(RNRS(Rtx0ty0tx1ty1((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_boundsg
s

s\
        (property) Returns (:attr:`x0`, :attr:`y0`, :attr:`width`,
        :attr:`height`).c


Cs|j�j
�j�S(
N(RNRSRO(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_extentsn
s
sM
        (property) Returns (:attr:`x0`, :attr:`y0`, :attr:`x1`, :attr:`y1`).c


Cst�S(
N(
R
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRNs
s
cCsI|j\}}||kr3|
|kr3|
|k
pH|
|koH|
|k
S(
s_
        Returns True if *x* is between or equal to :attr:`x0` and
        :attr:`x1`.
        (
t	intervalx(Rt
xRhRj((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt	containsxv
s


cCsI|j\}}||kr3|
|kr3|
|k
pH|
|koH|
|k
S(
s_
        Returns True if *y* is between or equal to :attr:`y0` and
        :attr:`y1`.
        (
t	intervaly(Rt
yRiRk((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt	containsy�
s


cCs|j|
�
o|j
|�
S(
sn
        Returns *True* if (*x*, *y*) is a coordinate inside the
        bounding box or on its edge.
        (RpRs(RRoRr((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytcontains�
sc
Cs�|j�\}}}}|
j�\}}}}	||krL||}}n||krh||}}n||kr�||}}n|	|kr�||	}	}n||kp�|	|kp�||kp�||kS(
si
        Returns True if this bounding box overlaps with the given
        bounding box *other*.
        (
Rm(
Rtothertax1tay1tax2tay2tbx1tby1tbx2tby2((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytoverlaps�
s










cCsI|j\}}||kr3|
|kr3|
|kpH|
|koH|
|kS(
sd
        Returns True if *x* is between but not equal to :attr:`x0` and
        :attr:`x1`.
        (
Rn(RRoRhRj((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytfully_containsx�
s


cCsI|j\}}||kr3t
|kr3t
|kpHt
|koHt
|kS(
sd
        Returns True if *y* is between but not equal to :attr:`y0` and
        :attr:`y1`.
        (RqRo(RRrRiRk((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytfully_containsy�
s


cCs|j|
�
o|j
|�
S(
sr
        Returns True if (*x*, *y*) is a coordinate inside the bounding
        box, but not on its edge.
        (RR�(RRoRr((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytfully_contains�
s
c
Cs�|j�\}}}}|
j�\}}}}	||krL||}}n||krh||}}n||kr�||}}n|	|kr�||	}	}n||k
p�|	|k
p�||kp�||kS(
s�
        Returns True if this bounding box overlaps with the given
        bounding box *other*, but not on its edge alone.
        (
Rm(
RRuRvRwRxRyRzR{R|R}((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytfully_overlaps�
s










cCst|
j
|j��
�
S(
sk
        Return a new :class:`Bbox` object, statically transformed by
        the given transform.
        (RMt	transformRN(RR�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyttransformed�
scCst|
j
�j|j��
�
S(
sz
        Return a new :class:`Bbox` object, statically transformed by
        the inverse of the given transform.
        (RMtinvertedR�RN(RR�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytinverse_transformed�
sg�?t
CitSWt
Sg�?tSEt
EtNEt
NtNWt
Wc
Cs�|d
kr|}n|j
\}}}}t|
t�rO|j|
\}}n|
\}}|j
\}	}
}}t|j|||||	|||||
g�
S(sS
        Return a copy of the :class:`Bbox`, shifted to position *c*
        within a container.

        *c*: may be either:

          * a sequence (*cx*, *cy*) where *cx* and *cy* range from 0
            to 1, where 0 is left or bottom and 1 is right or top

          * a string:
            - 'C' for centered
            - 'S' for bottom-center
            - 'SE' for bottom-left
            - 'E' for left
            - etc.

        Optional argument *container* is the box within which the
        :class:`Bbox` is positioned; it defaults to the initial
        :class:`Bbox`.
        N(Rtboundst
isinstancetstrtcoefsRMt_points(
Rt
ct	containert
lt
bt
wt
htcxtcyt
Lt
BR�t
H((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytanchored�
s
	




	

cCs?|j\}}t
|jd
|jd
|
|||gg�
S(s!

        Return a copy of the :class:`Bbox`, shrunk by the factor *mx*
        in the *x* direction and the factor *my* in the *y* direction.
        The lower left corner of the box remains unchanged.  Normally
        *mx* and *my* will be less than 1, but this is not enforced.
        i(tsizeRMR�(RtmxtmyR�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytshrunks


cCs�|
d
kr|d
kst�
|dkr3|}n|j\}}||
|}||k
re|}n|||
}|}t|jd
|jd
||fg�
S(s�

        Return a copy of the :class:`Bbox`, shrunk so that it is as
        large as it can be while having the desired aspect ratio,
        *box_aspect*.  If the box coordinates are relative---that
        is, fractions of a larger box such as a figure---then the
        physical aspect ratio of that figure is specified with
        *fig_aspect*, so that *box_aspect* can also be given as a
        ratio of the absolute dimensions, not the relative dimensions.
        iN(tAssertionErrorRR�RMR�(Rt
box_aspectR�t
fig_aspectR�R�R�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytshrunk_to_aspects


	



	



c
Gs�g}d
g
t|
�
dg
}|j
�\}}}}||}xZt|d |d�D]A\}	}
|jt||	||g||
||gg�
�

qZW|S(s�
        e.g., ``bbox.splitx(f1, f2, ...)``

        Returns a list of new :class:`Bbox` objects formed by
        splitting the original one with vertical lines at fractional
        positions *f1*, *f2*, ...
        ii
i����(RRRmtziptappendRM(RRtboxestxfRhRiRjRkR�txf0txf1((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytsplitx3s




$
9
c
Gs�g}d
g
t|
�
dg
}|j
�\}}}}||}xZt|d |d�D]A\}	}
|jt|||	|g|||
|gg�
�

qZW|S(s�
        e.g., ``bbox.splitx(f1, f2, ...)``

        Returns a list of new :class:`Bbox` objects formed by
        splitting the original one with horizontal lines at fractional
        positions *f1*, *f2*, ...
        ii
i����(RRRmR�R�RM(RRR�tyfRhRiRjRkR�tyf0tyf1((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytsplityCs




$
9
cCs�t|
�
d
krd
St
j|
�
}
|j�\}}}}t
j|
dd�d
f|�
}t
j|
dd�df|�
}t
j|
dd�d
f|�
}t
j|
dd�df|�
}	t||�
t||	�
dk
}
t
j|
�
S(sx
        Count the number of vertices contained in the :class:`Bbox`.

        *vertices* is a Nx2 Numpy array.
        iNi
i(RRIRJRmtsigntabstsum(RtverticesRhRiRjRktdx0tdy0tdx1tdy1tinside((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytcount_containsSs



#
#
#
#
$
cCs
t||
�S(
s�
        Count the number of bounding boxes that overlap this one.

        bboxes is a sequence of :class:`BboxBase` objects
        (
R(Rtbboxes((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytcount_overlapsdscCsj|j}|j
}|
||d
}|||d
}tj||g||gg�
}t|j|�
S(s�
        Return a new :class:`Bbox` which is this :class:`Bbox`
        expanded around its center by the given factors *sw* and
        *sh*.
        g@(twidththeightRItarrayRMR�(RtswtshR�R�tdeltawtdeltaht
a((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytexpandedls	
	


#
cCs.|j�}t
||
|
g|
|
gg�
S(
si
        Return a new :class:`Bbox` that is padded on all four sides by
        the given value.
        (RNRM(Rt
pRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytpaddedys
cCst|j
|
|f�
S(
se
        Return a copy of the :class:`Bbox`, statically translated by
        *tx* and *ty*.
        (RMR�(Rttxtty((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt
translated�sc
CsO|j�j
�\}
}}}tj|
|g|
|g||g||gg�
S(
s

        Return an array of points which are the four corners of this
        rectangle.  For example, if this :class:`Bbox` is defined by
        the points (*a*, *b*) and (*c*, *d*), :meth:`corners` returns
        (*a*, *b*), (*a*, *d*), (*c*, *b*) and (*c*, *d*).
        (RNRSRIR�(RR�R�t
rt
t((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytcorners�s
cCsJ|j�}t
�j|
�
j|�
}tj�}|j|d
t�


|S(s�
        Return a new bounding box that bounds a rotated version of
        this bounding box by the given radians.  The new bounding box
        is still aligned with the axes, of course.
        tignore(R�tAffine2DtrotateR�RMtunittupdate_from_data_xytTrue(RtradiansR�tcorners_rotatedtbbox((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytrotated�s




c
	Cs
t|�
st
�
t|�
d
kr,|dStj}
tj}tj}tj}x�|D]�}|j�}|dd�df}|dd�d
f}t|
tj|�
�}
t|tj|�
�}t|tj|�
�}t|tj|�
�}qYWtj|
|||�S(sO
        Return a :class:`Bbox` that contains all of the given bboxes.
        i
iN(	RR�RItinfRNR[R^RMtfrom_extents(	R�RhRiRjRkR�RKtxstys((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytunion�s 
	
	











N(g�?g�?(ii(g�?i(g�?i(g�?g�?(g�?g�?(g�?g�?(ig�?(ig�?(NR,R=R>R�RBRRDRLtstaticmethodR"RRQRTRUtpropertyRRhRVRiRWRjRXRkRYtp0RZtp1R\txminR]tyminR_txmaxR`tymaxRaR[RbR^RcRnRdRqReR�RfR�RgR�RlR�RmtextentsRNRpRsRtR~RR�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRE�s�



																	
		
		
		
				
														
			
	
			
	
				










!						
			
	RMcBs<eZ
dZd
�Zer6eZd�Zd�Znejddgddggej	�Z
ed��
Zed��
Z
ed��
Zd	�ZeZd
�Zd d�
Zd eed�Zd eed
�Zd�Zeeje�Zd�Zeeje�Zd�Zeej e�Z!d�Z"eej#e"�Z$d�Z%eej&e%�Z'd�Z(eej)e(�Z*d�Z+eej,e+�Z-d�Z.eej/e.�Z0d�Z1eej2e1�Z3d�Z4ee4�
Z5d�Z6ee6�
Z7d�Z8ee8�
Z9d�Z:d�Z;d�Z<d�Z=d�Z>d�Z?RS(!s!
    A mutable bounding box.
    cCs\tj
|�

tj|
tj�|_tjd
d
g�
|_t|_	|jj
�|_dS(s

        *points*: a 2x2 numpy array of the form [[x0, y0], [x1, y1]]

        If you need to create a :class:`Bbox` object from another form
        of data, consider the static methods :meth:`unit`,
        :meth:`from_bounds` and :meth:`from_extents`.
        gH�����z>N(RERRIRJtfloat_R�R�t_minposR�t_ignoreROt_points_orig(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s




	cCs|j|
�

|j
|
�

dS(
N(RLt	___init__(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s


c

Cs!|j|j
�

tj|�

dS(
N(RLR�RR(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s

gg�?cCsttj
j��
S(
s_
        (staticmethod) Create a new unit :class:`Bbox` from (0, 0) to
        (1, 1).
        (RMt_unit_valuesRO(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��scCstj
||
|||
|�S(
s�
        (staticmethod) Create a new :class:`Bbox` from *x0*, *y0*,
        *width* and *height*.

        *width* and *height* may be negative.
        (RMR�(RhRiR�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytfrom_bounds�scGs.tj
|d
tj�

jdd�}
t|
�
S(s�
        (staticmethod) Create a new Bbox from *left*, *bottom*,
        *right* and *top*.

        The *y*-axis increases upwards.
        tdtypei(RIR�R�treshapeRM(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s$
c

Csd
t|j
�
S(NsBbox(%s)(treprR�(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt__repr__�s
cCs
|
|_d
S(s�

        Set whether the existing bounds of the box should be ignored
        by subsequent calls to :meth:`update_from_data` or
        :meth:`update_from_data_xy`.

        *value*:

           - When True, subsequent calls to :meth:`update_from_data`
             will ignore the existing bounds of the :class:`Bbox`.

           - When False, subsequent calls to :meth:`update_from_data`
             will include the existing bounds of the :class:`Bbox`.
        N(
R�(RR((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��scCs\tj
d
�

tj|
jt|
�
df�
|jt|�
df�
f�
}|j||�S(s
        Update the bounds of the :class:`Bbox` based on the passed in
        data.  After updating, the bounds will have positive *width*
        and *height*; *x0* and *y0* will be the minimal values.

        *x*: a numpy array of *x*-values

        *y*: a numpy array of *y*-values

        *ignore*:
           - when True, ignore the existing bounds of the :class:`Bbox`.
           - when False, include the existing bounds of the :class:`Bbox`.
           - when None, use the last value passed to :meth:`ignore`.
        sRupdate_from_data requires a memory copy -- please replace with update_from_data_xyi
(RGRHRIthstackR�RR�(RRoRrR�txy((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytupdate_from_data
s

?
cCs�|dkr|j
}n|
jjd
kr.dSt|
d|j|j|�\}}}|r�|j�
|r�|dd�d
f|jdd�d
f<|d
|jd
<n|r�|dd�df|jdd�df<|d|jd<q�ndS(sa
        Update the bounds of the :class:`Bbox` based on the passed in
        data.  After updating, the bounds will have positive *width*
        and *height*; *x0* and *y0* will be the minimal values.

        *path*: a :class:`~matplotlib.path.Path` instance

        *ignore*:
           - when True, ignore the existing bounds of the :class:`Bbox`.
           - when False, include the existing bounds of the :class:`Bbox`.
           - when None, use the last value passed to :meth:`ignore`.

        *updatex*: when True, update the x values

        *updatey*: when True, update the y values
        iNi
(RR�R�R�RR�R�R(RtpathR�tupdatextupdateyRKtminpostchanged((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytupdate_from_paths


$



)


)
cCsEt|
�
d
krdSt
|
�
}|j|d|d|d|�

dS(sP
        Update the bounds of the :class:`Bbox` based on the passed in
        data.  After updating, the bounds will have positive *width*
        and *height*; *x0* and *y0* will be the minimal values.

        *xy*: a numpy array of 2D points

        *ignore*:
           - when True, ignore the existing bounds of the :class:`Bbox`.
           - when False, include the existing bounds of the :class:`Bbox`.
           - when None, use the last value passed to :meth:`ignore`.

        *updatex*: when True, update the x values

        *updatey*: when True, update the y values
        iNR�R�R�(RRR�(RR�R�R�R�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�Bs



cCs|
|jd<|j
�
dS(Ni(ii(R�R(RR5((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_set_x0Zs


cCs|
|jd<|j
�
dS(Nii
(ii
(R�R(RR5((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_set_y0_s


cCs|
|jd<|j
�
dS(Ni
i(i
i(R�R(RR5((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_set_x1ds


cCs|
|jd<|j
�
dS(Ni
(i
i
(R�R(RR5((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_set_y1is


cCs|
|jd
<|j
�
dS(Ni(R�R(RR5((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_set_p0ns


cCs|
|jd
<|j
�
dS(Ni
(R�R(RR5((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_set_p1ss


cCs'|
|jdd�d
f<|j
�
dS(Ni(R�R(Rtinterval((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_set_intervalxxs

cCs'|
|jdd�d
f<|j
�
dS(Ni
(R�R(RR
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_set_intervaly}s

cCss|
\}}}}tj
||g||||ggtj�}tj|j|k�
ro||_|j�
ndS(
N(RIR�R�tanyR�R(RR�R�R�R�R�RK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_set_bounds�s


/

	
c


Cs|jS(
N(
R�(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_minpos�s
c

Cs|jd
S(Ni(
R�(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_minposx�s
c

Cs|jd
S(Ni
(
R�(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_minposy�s
c

Csd
|_|j
S(sy
        Get the points of the bounding box directly as a numpy array
        of the form: [[x0, y0], [x1, y1]].
        i(R
R�(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRN�s	
cCs2tj
|j|
k�
r.|
|_|j�
nd
S(s�
        Set the points of the bounding box directly from a numpy array
        of the form: [[x0, y0], [x1, y1]].  No error checking is
        performed, as this method is mainly for internal use.
        N(RIR
R�R(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt
set_points�s
	
cCs>tj
|j|
j�k�
r:|
j�|_|j�
nd
S(sb
        Set this bounding box from the "frozen" bounds of another
        :class:`Bbox`.
        N(RIR
R�RNR(RRu((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR;�s

c

Cs|j�p|j
�S(
s.return whether the bbox has changed since init(tmutatedxtmutatedy(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytmutated�sc

Cs2|jd|j
dkp1|jd|j
dkS(s3return whether the x-limits have changed since initii
(ii(ii(i
i(i
i(R�R�(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR
�s
c

Cs2|jd|j
dkp1|jd|j
dkS(s3return whether the y-limits have changed since initii
(ii
(ii
(i
i
(i
i
(R�R�(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR

�s
N(@R,R=R>RRDR�RRIR�R�R�R�R�R�R�R�t__str__R�RR�R�R�R�R�R�RERURhR�RVRiR�RWRjR
RXRkR

RYR�R
RZR�R
RcRnR
RdRqR
RlR�R
R�R	
tminposxR

tminposyRNR
R;R
R
R

(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRM�s\	

	'

		$														
				tTransformedBboxcBsVeZ
dZd
�Zd�ZeZd�Zejje_erTeZ	d�ZnRS(s�
    A :class:`Bbox` that is automatically transformed by a given
    transform.  When either the child bounding box or transform
    changes, the bounds of this bbox will update accordingly.
    cCs�|
jst
�
t|t�s$t
�
|jd
ks9t
�
|jd
ksNt
�
tj|�

|
|_||_	|j
|
|�
d|_dS(s]
        *bbox*: a child :class:`Bbox`

        *transform*: a 2D :class:`Transform`
        iN(
RBR�R�t	Transformt
input_dimstoutput_dimsRERt_bboxt
_transformRRR�(RR�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s




	
	

c

Csd
|j|j
fS(NsTransformedBbox(%s, %s)(R
R
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s
c
CsU|jrN|j
j|jj��
}
tjj|
d
�}
|
|_d|_n|jS(Ngi(	R
R
R�R
RNRIRtfilledR�(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRN�s
	


	

c
Cs|j�}
|j
|
�

|
S(
N(t_get_pointsRL(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRN�s



(
R,R=R>RR�R
RNRMRDR
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR
�s
			

R
cBs�eZ
dZdZdZeZeZd
�Z	d�Z
d�Zd�Zd�Z
d�Zd�Zd�Zd	�Zd
�Zd�Zedd
�Zd�ZRS(s
    The base class of all :class:`TransformNode` instances that
    actually perform a transformation.

    All non-affine transformations should be subclasses of this class.
    New affine transformations should be subclasses of
    :class:`Affine2D`.

    Subclasses of this class should override the following members (at
    minimum):

      - :attr:`input_dims`
      - :attr:`output_dims`
      - :meth:`transform`
      - :attr:`is_separable`
      - :attr:`has_inverse`
      - :meth:`inverted` (if :meth:`has_inverse` can return True)

    If the transform needs to do something non-standard with
    :class:`mathplotlib.path.Path` objects, such as adding curves
    where there were once line segments, it should override:

      - :meth:`transform_path`
    cCs6t|
t
�rt||
�Std
t|
�
�
�
dS(sc
        Composes two transforms together such that *self* is followed
        by *other*.
        s,Can not add Transform to object of type '%s'N(R�R
tcomposite_transform_factoryt	TypeErrorttype(RRu((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt__add__s



cCs6t|
t
�rt|
|�Std
t|
�
�
�
dS(sc
        Composes two transforms together such that *self* is followed
        by *other*.
        s,Can not add Transform to object of type '%s'N(R�R
R
R
R
(RRu((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt__radd__s



c

Os
t�
d
S(sP
        Used by C/C++ -based backends to get at the array matrix data.
        N(
R
(RRRP((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRQ)sc
Cs
t��
d
S(s�
        Performs the transformation on the given array of values.

        Accepts a numpy array of shape (N x :attr:`input_dims`) and
        returns a numpy array of shape (N x :attr:`output_dims`).
        N(
R
(Rtvalues((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�/sc
Cs|
S(
s
        Performs only the affine part of this transformation on the
        given array of values.

        ``transform(values)`` is always equivalent to
        ``transform_affine(transform_non_affine(values))``.

        In non-affine transformations, this is generally a no-op.  In
        affine transformations, this is equivalent to
        ``transform(values)``.

        Accepts a numpy array of shape (N x :attr:`input_dims`) and
        returns a numpy array of shape (N x :attr:`output_dims`).
        ((RR
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyttransform_affine8scCs
|j|
�
S(
s�

        Performs only the non-affine part of the transformation.

        ``transform(values)`` is always equivalent to
        ``transform_affine(transform_non_affine(values))``.

        In non-affine transformations, this is generally equivalent to
        ``transform(values)``.  In affine transformations, this is
        always a no-op.

        Accepts a numpy array of shape (N x :attr:`input_dims`) and
        returns a numpy array of shape (N x :attr:`output_dims`).
        (
R�(RR
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyttransform_non_affineIsc


Cst�S(
s8
        Get the affine part of this transform.
        (
tIdentityTransform(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt
get_affineYscCs8t|
�
|j
kst�
|jtj|
g
�
�
d
S(s

        A convenience function that returns the transformed copy of a
        single point.

        The point is given as a sequence of length :attr:`input_dims`.
        The transformed point is returned as a sequence of length
        :attr:`output_dims`.
        i(RR
R�R�RIRJ(Rtpoint((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyttransform_point_s	
cCs"t|j
|
j�
|
j|
j�S(
s�
        Returns a transformed copy of path.

        *path*: a :class:`~matplotlib.path.Path` instance.

        In some cases, this transform may insert curves into the path
        that began as line segments.
        (RR�R�tcodest_interpolation_steps(RR�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyttransform_pathks	
c
Cs|
S(
s

        Returns a copy of path, transformed only by the affine part of
        this transform.

        *path*: a :class:`~matplotlib.path.Path` instance.

        ``transform_path(path)`` is equivalent to
        ``transform_path_affine(transform_path_non_affine(values))``.
        ((RR�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyttransform_path_affinews
cCs"t|j
|
j�
|
j|
j�S(
s!

        Returns a copy of path, transformed only by the non-affine
        part of this transform.

        *path*: a :class:`~matplotlib.path.Path` instance.

        ``transform_path(path)`` is equivalent to
        ``transform_path_affine(transform_path_non_affine(values))``.
        (RR!
R�R&
R'
(RR�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyttransform_path_non_affine�s

g�h㈵��>c
CsA
|jd
ks|j
d
kr-td�
�
n|jdd
ksFt�
tj|
j�
|
jdkow|jdkn
s�t�
|s�|
dtj}
n||tjtj	|
�
tj
|
�
f}|j|�
}|j|�
}||}tj|dd�df|dd�df�}	|s=
|	dtj}	n|	S(s�
        Performs transformation on a set of angles anchored at
        specific locations.

        The *angles* must be a column vector (i.e., numpy array).

        The *pts* must be a two-column numpy array of x,y positions
        (angle transforms currently only work in 2D).  This array must
        have the same number of rows as *angles*.

        *radians* indicates whether or not input angles are given in
         radians (True) or degrees (False; the default).

        *pushoff* is the distance to move away from *pts* for
         determining transformed angles (see discussion of method
         below).

        The transformed angles are returned in an array with the same
        size as *angles*.

        The generic version of this method uses a very generic
        algorithm that transforms *pts*, as well as locations very
        close to *pts*, to find the angle in the transformed system.
        isOnly defined in 2Di
ig�f@N(
R
R
R
R&R�RItprodtpitc_tcostsinR�tarctan2(
RtanglestptsR�tpushofftpts2ttptsttpts2t
dR�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyttransform_angles�s
<
-


2
c


Cs
t��
d
S(s,

        Return the corresponding inverse transformation.

        The return value of this method should be treated as
        temporary.  An update to *self* does not cause a corresponding
        update to its inverted copy.

        ``x === self.inverted().transform(self.transform(x))``
        N(
R
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s
N(R,R=R>RR
R
RAthas_inversetis_separableR
R
RQR�R 
R!
R#
R%
R(
R)
R*
R8
R�(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR
�s$
	
	
										
9tTransformWrappercBs�eZ
dZeZeZd
�Zd�ZeZ	d�Z
ej
je
_d�Zd�Z
d�Zee�
Zd�Zee�
ZRS(s
    A helper class that holds a single child transform and acts
    equivalently to it.

    This is useful if a node of the transform tree must be replaced at
    run time with a transform of a different type.  This class allows
    that replacement to correctly trigger invalidation.

    Note that :class:`TransformWrapper` instances must have the same
    input and output dimensions during their entire lifetime, so the
    child transform may only be replaced with another child transform
    of the same dimensions.
    cCsTt|
t
�st�
t
j|�

|
j|_|
j|_|j|
�

d
|_dS(st
        *child*: A class:`Transform` instance.  This child may later
        be replaced with :meth:`set`.
        iN(R�R
R�RR
R
t_setR
(RR((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s





c

Csd
|jS(NsTransformWrapper(%r)(
t_child(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s
c


Cs
|jj
�S(
N(R=
R"(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR"�s
cCsz|
|_|j
|
�

|
j|_|
j|_|
j|_|
j|_|
j|_|
j|_|
j|_|
j	|_	dS(
N(
R=
RR�R 
R!
R(
R)
R*
R#
R�(RR((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR<
�s
	








cCs]|
j|jkst
�
|
j|jks0t
�
|j|
�

d
|_|j�
d
|_dS(s�
        Replace the current child of this transform with another one.

        The new child must have the same number of input and output
        dimensions as the current child.
        iN(R
R�R
R<
R
R(RR((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR;	s

	


c


Cs
|jj
S(
N(R=
R:
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_is_separables
c


Cs
|jj
S(
N(R=
R9
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_has_inverses
(R,R=R>R�RRARRR�R
R"R
R<
R;R>
R�R:
R?
R9
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR;
�s


	
			
			t
AffineBasecBs�eZ
dZeZd
�Zd�Zed��
Zd�Z	d�Z
ej
je
_d�Zejje_d�Z
ej
je
_d�Zejje_RS(	sW
    The base class of all affine transformations of any number of
    dimensions.
    c

Cstj
|�

d|_dS(
N(R
RRt	_inverted(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR)s


c

Os
|j�S(
N(
t
get_matrix(RRRP((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRQ-s
cCstj
|
|�S(
sj
        Concatenates two transformation matrices (represented as numpy
        arrays) together.
        (RItdot(R�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_concat0sc


Cs
t��
d
S(sL
        Get the underlying transformation matrix as a numpy array.
        N(
R
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRB
8sc
Cs|
S(
N((RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR!
>s
cCs
|j|
�
S(
N(
R(
(RR�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR)
Bs
c
Cs|
S(
N((RR�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR*
Fs
c


Cs|S(
N((
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR#
Js
(R,R=R>R�RRRQR�RD
RB
R!
R
R)
R*
R#
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR@
"s
							tAffine2DBasecBs�eZ
dZd
Zd
Zd�Zejje_d�Zee�
Z	d�Z
d�Zed��
Z
d�Zd�Zejje_er�eZd	�Znejje_eZejje_d
�Zejje_RS(s�

    The base class of all 2D affine transformations.

    2D affine transformations are performed using a 3x3 numpy array::

        a c e
        b d f
        0 0 1

    This class provides the read-only interface.  For a mutable 2D
    affine transformation, use :class:`Affine2D`.

    Subclasses of this class will generally only need to override a
    constructor and :meth:`get_matrix` that generates a custom 3x3 matrix.
    ic

Cst|j
�j��
S(
N(R�RB
RO(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR"hs
c
Cs*|j�}
|
ddko)|
ddkS(Nii
g(ii
(i
i(
RB
(Rtmtx((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR>
ls

c

Os
|j�S(
N(
RB
(RRRP((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRQqs
c
Cs,|j�}
t
|
d
 jdd�j��
S(sM
        Return the values of the matrix as a sequence (a,b,c,d,e,f)
        iii
(RB
ttupletswapaxesRS(RRF
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt	to_valuests
cCs7tj
|||g|
||gd
d
dggtj�S(s�
        (staticmethod) Create a new transformation matrix as a 3x3
        numpy array of the form::

          a c e
          b d f
          0 0 1
        gg�?(RIR�R�(R�R�R�R7
t
et
f((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytmatrix_from_values{s
cCsV|j�}t
|
t�rIt|
j|�}tj|d
tj|
�
�

St|
|�S(Ntmask(RB
R�tMaskedArrayR
tdataRtgetmask(RRKRF
ttpoints((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s





cCs|j�}t
|
|�S(
N(RB
R
(RR$
RF
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR%
�s

cCsNtj
|
�
rAt|
tj�rAtjd
dtt�
�

n|j	|
�
S(Ns/A non-numpy array of type %s was passed in for s%transformation.  Please correct this.(
RRFR�RItndarrayRGRHR
R
R
(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s





c
CsL|jdks|jrE|j�}
tt|
�
�
|_d
|_n|jS(Ni(RA
RR
RB
R�R(RRF
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s





(R,R=R>R
R
R"R@
R>
R�R:
RQRI
R�RL
R�R%
RDR
R 
R�(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRE
Os*
						


	R�cBs�eZ
dZdd
�
Zd�ZeZd�Zed��
Z	d�Z
d�Zd�Zed��
Z
d	�Zd
�Zd�Zd�Zd
�Zd�Zdd�
Zd�Zee�
ZRS(s-
    A mutable 2D affine transformation.
    cCsttj
|�

|
dkr+tjd
�
}
n3tr^tj|
tj�}
|
jdks^t	�
n|
|_
d|_dS(s�
        Initialize an Affine transform from a 3x3 numpy float array::

          a c e
          b d f
          0 0 1

        If *matrix* is None, initialize with the identity transform.
        iiN(ii(RE
RRRItidentityRDRJR�R&R�t_mtxR
(Rtmatrix((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s







	
c

Csd
t|j
�
S(NsAffine2D(%s)(R�RT
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s
cCs5t|
t
�r1|j�|
j�kj�r1d
SdS(Nii����(R�R�RB
tall(RRu((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt__cmp__�s



cCs=tt
j||||
||d
d
dg	t
j�jd�
�
S(s�
        (staticmethod) Create a new Affine2D instance from the given
        values::

          a c e
          b d f
          0 0 1
        gg�?i(ii(R�RIR�R�R�(R�R�R�R7
RJ
RK
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytfrom_values�s

0
c

Csd
|_|j
S(s�
        Get the underlying transformation matrix as a 3x3 numpy array::

          a c e
          b d f
          0 0 1
        i(R
RT
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRB
�s	
cCs|
|_|j
�
d
S(s�
        Set the underlying transformation matrix from a 3x3 numpy array::

          a c e
          b d f
          0 0 1
        N(RT
R(RRF
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt
set_matrix�s	
cCs2t|
t
�st�
|
j�|_|j�
d
S(so
        Set this transformation from the frozen copy of another
        :class:`Affine2DBase` object.
        N(R�RE
R�RB
RT
R(RRu((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR;�s

cCstt
jd
�
�
S(s�
        (staticmethod) Return a new :class:`Affine2D` object that is
        the identity transform.

        Unless this transform will be mutated later on, consider using
        the faster :class:`IdentityTransform` class instead.
        i(R�RIRS
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRS
�s	c

Cs tj
d
�
|_|j�
|S(sH
        Reset the underlying matrix to the identity transform.
        i(RIRS
RT
R(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytclears


cCs~tj
|
�
}tj|
�
}tj||d
g||d
gd
d
dggtj�}tj||j�|_|j�
|S(s�
        Add a rotation (in radians) to this transform in place.

        Returns *self*, so this method can easily be chained with more
        calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
        and :meth:`scale`.
        gg�?(RIR.
R/
R�R�RC
RT
R(RtthetaR�R�t
rotate_mtx((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s


(




cCs|j|
t
jd
�
S(s�
        Add a rotation (in degrees) to this transform in place.

        Returns *self*, so this method can easily be chained with more
        calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
        and :meth:`scale`.
        g�f@(R�RIR,
(Rtdegrees((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt
rotate_deg!scCs'|j|
|�j
|�
j|
|�S(
s�
        Add a rotation (in radians) around the point (x, y) in place.

        Returns *self*, so this method can easily be chained with more
        calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
        and :meth:`scale`.
        (t	translateR�(RRoRrR[
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt
rotate_around+scCs'|j|
|�j
|�
j|
|�S(
s�
        Add a rotation (in degrees) around the point (x, y) in place.

        Returns *self*, so this method can easily be chained with more
        calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
        and :meth:`scale`.
        (R_
R^
(RRoRrR]
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytrotate_deg_around5scCs_tj
d
d|
gdd
|gddd
ggtj�}tj||j�|_|j�
|S(s�
        Adds a translation in place.

        Returns *self*, so this method can easily be chained with more
        calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
        and :meth:`scale`.
        g�?g(RIR�R�RC
RT
R(RR�R�t
translate_mtx((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR_
?s
'




cCst|dkr|
}nt
j|
d
d
gd
|d
gd
d
dggt
j�}t
j||j�|_|j�
|S(s3

        Adds a scale in place.

        If *sy* is None, the same scale is applied in both the *x*- and
        *y*-directions.

        Returns *self*, so this method can easily be chained with more
        calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
        and :meth:`scale`.
        gg�?N(RRIR�R�RC
RT
R(Rtsxtsyt	scale_mtx((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytscaleNs
	

'




c
Cs*|j�}
|
ddko)|
ddkS(Nii
g(ii
(i
i(
RB
(RRF
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR>
bs

N(R,R=R>RRR�R
RW
R�RX
RB
RY
R;RS
RZ
R�R^
R`
Ra
R_
Rf
R>
R�R:
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s&									
	
	
		R"
cBs

eZ
dZejd
�
Zd�Zejje_d�ZeZ	d�Z
ej
je
_d�Zejje_eZejje_eZ
ej
je
_d�Zejje_eZejje_eZejje_d�Zejje_eZejje_RS(sX
    A special class that does on thing, the identity transform, in a
    fast way.
    ic


Cs|S(
N((
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR"os
c


Csd
S(NsIdentityTransform()((
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�ss
c


Cs|jS(
N(
RT
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRB
ws
c
Cs|
S(
N((RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�{s
c
Cs|
S(
N((RR�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR(
�s
c


Cs|S(
N((
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR#
�s
(R,R=R>RIRS
RT
R"RE
R�R
RB
R�R 
R!
R(
R)
R*
R#
R�(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR"
hs0
				

	

	
tBlendedGenericTransformcBs�eZ
dZd
Zd
ZeZeZd�Zd�Z	e
e	�
Zd�Ze
jje_d�ZeZd�Ze
jje_d�Ze
jje_d�Ze
jje_d	�Ze
jje_d
�Ze
jje_RS(s�
    A "blended" transform uses one transform for the *x*-direction, and
    another transform for the *y*-direction.

    This "generic" version can handle any given child transform in the
    *x*- and *y*-directions.
    icCs<tj
|�

|
|_||_|j|
|�
d
|_d
S(s�

        Create a new "blended" transform using *x_transform* to
        transform the *x*-axis and *y_transform* to transform the
        *y*-axis.

        You will generally not call this constructor directly but use
        the :func:`blended_transform_factory` function instead, which
        can determine automatically which kind of blended transform to
        create.
        N(R
Rt_xt_yRRt_affine(Rtx_transformty_transform((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s



	
	

c

Cs|jj
o|jj
S(
N(Rh
RRi
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_get_is_affine�s
c

Cst|j
j�|jj��S(
N(tblended_transform_factoryRh
R"Ri
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR"�s
c

Csd
|j|j
fS(NsBlendedGenericTransform(%s,%s)(Rh
Ri
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s
cCsj
|j}|j
}||kr:|jd
kr:|j|
�
S|jd
krq|j|
�
dd�dd�f}n:|j|
dd�df�
}|jt|�
df�
}|jd
kr�|j|
�
dd�dd�f}n:|j|
dd�df�
}|jt|�
df�
}t|t�s:
t|t�rP
tj	||fd�St
j	||fd�SdS(Niii
(Rh
Ri
R
R�R�RR�RN
RtconcatenateRI(RRKRoRrtx_pointsty_points((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s
	
	


(

(

cCs|j�j
|
�
S(
N(R#
R�(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR 
�s
cCs)|jj
r|jj
r|
S|j|
�
S(
N(Rh
RRi
R�(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR!
�s


c

Cst|j
j�|jj��S(
N(Rg
Rh
R�Ri
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s
c
Cs�|js|j
dkr�|jjr�|jjr�|j|jkrW|jj�|_
q�|jj�j�}
|jj�j�}tj	|
d
|ddddgf�
}t
|�
|_
nt�|_
d
|_n|j
S(Nii
gg�?(R
Rj
RRh
RRi
R#
RB
RItvstackR�R"
(Rtx_mtxty_mtxRF
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR#
�s




)


(R,R=R>R
R
R�R:
RRRm
R�RR"R
R�R
R�R 
R!
R�R#
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRg
�s,



									tBlendedAffine2DcBsDeZ
dZeZd
�Zd�ZeZd�Ze	jje_RS(s�
    A "blended" transform uses one transform for the *x*-direction, and
    another transform for the *y*-direction.

    This version is an optimization for the case where both child
    transforms are of type :class:`Affine2DBase`.
    cCs�|
jst
�
|jst
�
|
js-t
�
|js<t
�
tj|�

|
|_||_|j|
|�
tj|�

d
|_
d
S(s�

        Create a new "blended" transform using *x_transform* to
        transform the *x*-axis and *y_transform* to transform the
        *y*-axis.

        Both *x_transform* and *y_transform* must be 2D affine
        transforms.

        You will generally not call this constructor directly but use
        the :func:`blended_transform_factory` function instead, which
        can determine automatically which kind of blended transform to
        create.
        N(RR�R:
R
RRh
Ri
RRE
RRT
(RRk
Rl
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRs




	
	


c

Csd
|j|j
fS(NsBlendedAffine2D(%s,%s)(Rh
Ri
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�#s
c
Cs�|jr�|j
|jkr0|j
j�|_nJ|j
j�}
|jj�}tj|
d
|ddddgf�
|_d|_d
|_n|jS(Nii
gg�?(	R
Rh
Ri
RB
RT
RIRr
RRA
(RRs
Rt
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRB
's
	


,
	

(
R,R=R>R�R:
RR�R
RB
RE
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRu
�s
			cCs8t|t
�r+t|
t
�r+t||
�St||
�S(
s�
    Create a new "blended" transform using *x_transform* to transform
    the *x*-axis and *y_transform* to transform the *y*-axis.

    A faster version of the blended transform is returned for the case
    where both child transforms are affine.
    (R�RE
Ru
Rg
(Rk
Rl
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRn
8s



tCompositeGenericTransformcBs.
eZ
dZeZd
�Zd�Zejje_d�Ze	e�
Z
d�Ze	e�
Zd�Z
e
Zd�Zejje_d�Zejje_d�Zejje_d	�Zejje_d
�Zejje_d�Zejje_d�Zejje_d
�Zejje_RS(s�
    A composite transform formed by applying transform *a* then
    transform *b*.

    This "generic" version can handle any two arbitrary
    transformations.
    cCsc|
j|j
kst�
|
j
|_
|j|_tj|�

|
|_||_|j|
|�
d
S(sl

        Create a new composite transform that is the result of
        applying transform *a* then transform *b*.

        You will generally not call this constructor directly but use
        the :func:`composite_transform_factory` function instead,
        which can automatically choose the best kind of composite
        transform instance to create.
        N(R
R
R�R
Rt_at_bR(RR�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRPs




	
	
c
CsGd
|_t
|jj�|jj��}
t|
t�sC|
j�S|
S(Ni(R
R
Rw
R"Rx
R�Rv
(RR"((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR"cs

	
!



c

Cs|jj
o|jj
S(
N(Rw
RRx
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRm
ks
c

Cs|jj
o|jj
S(
N(Rw
R:
Rx
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR>
os
c

Csd
|j|j
fS(Ns!CompositeGenericTransform(%s, %s)(Rw
Rx
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�ss
cCs|jj
|jj
|
�
�
S(
N(Rx
R�Rw
(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�ws
	
cCs|j�j
|
�
S(
N(R#
R�(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR 
|s
cCs8|jj
r|jj
r|
S|jj|jj|
�
�
S(
N(Rw
RRx
R!
R�(RRK((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR!
�s


	
cCs|jj
|jj
|
�
�
S(
N(Rx
R(
Rw
(RR�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR(
�s
	
cCs|jj
|jj|
�
�
S(
N(Rx
R)
Rw
R(
(RR�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR)
�s
	
cCs8|jj
r|jj
r|
S|jj|jj|
�
�
S(
N(Rw
RRx
R*
R(
(RR�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR*
�s


	
c

Cs]|jj
rL|jj
rLttj|jj�j�|jj�j���
S|jj�SdS(
N(Rw
RRx
R�RIRC
R#
RB
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR#
�s


c

Cst|j
j�|jj��S(
N(Rv
Rx
R�Rw
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s
(R,R=R>R�RRR"R
Rm
R�RR>
R:
R�R
R�R 
R!
R(
R)
R*
R#
R�(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRv
Fs6
													tCompositeAffine2DcBs>eZ
dZd
�Zd�ZeZd�Zejje_RS(s�
    A composite transform formed by applying transform *a* then transform *b*.

    This version is an optimization that handles the case where both *a*
    and *b* are 2D affines.
    cCs�|
j|j
kst�
|
j
|_
|j|_|
js?t�
|jsNt�
tj|�

|
|_||_|j|
|�
d
|_
d
S(s�

        Create a new composite transform that is the result of
        applying transform *a* then transform *b*.

        Both *a* and *b* must be instances of :class:`Affine2DBase`.

        You will generally not call this constructor directly but use
        the :func:`composite_transform_factory` function instead,
        which can automatically choose the best kind of composite
        transform instance to create.
        N(R
R
R�RRE
RRw
Rx
RRRT
(RR�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s





	
	

c

Csd
|j|j
fS(NsCompositeAffine2D(%s, %s)(Rw
Rx
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s
c

CsL|jrEt
j|jj�|jj��|_d|_d
|_n|jS(Ni(	R
RIRC
Rx
RB
Rw
RT
RRA
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRB
�s
	



	

(R,R=R>RR�R
RB
RE
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRy
�s
			cCs^t|t
�r|
St|
t
�r&|St|t�rQt|
t�rQt||
�St||
�S(
sv

    Create a new composite transform that is the result of applying
    transform a then transform b.

    Shortcut versions of the blended transform are provided for the
    case where both child transforms are affine, or one or the other
    is the identity transform.

    Composite transforms may also be created using the '+' operator,
    e.g.::

      c = a + b
    (R�R"
R@
Ry
Rv
(R�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR
�s






t
BboxTransformcBsDeZ
dZeZd
�Zd�ZeZd�Ze	jje_RS(sp
    :class:`BboxTransform` linearly transforms points from one
    :class:`Bbox` to another :class:`Bbox`.
    cCsc|
jst
�
|jst
�
tj|�

|
|_||_|j|
|�
d
|_d
|_	d
S(sw
        Create a new :class:`BboxTransform` that linearly transforms
        points from *boxin* to *boxout*.
        N(
RBR�RE
Rt_boxint_boxoutRRRT
RA
(Rtboxintboxout((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s


	
	

	
c

Csd
|j|j
fS(NsBboxTransform(%s, %s)(R{
R|
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s
c
Cs�|jr�|j
j\}
}}}|jj\}}}}||}	||}
trz|	d
ksk|
d
krztd�
�
ntj|	d|
|	|gd|
||
|gdddggtj�|_	d|_d
|_n|j	S(Nis0Transforming from or to a singular bounding box.gg�?(R
R{
R�R|
RDt
ValueErrorRIR�R�RT
RRA
(Rtinltinbtinwtinhtoutltoutbtoutwtouthtx_scalety_scale((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRB
s
	












	

(
R,R=R>R�R:
RR�R
RB
RE
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRz
�s
			tBboxTransformTocBsDeZ
dZeZd
�Zd�ZeZd�Ze	jje_RS(s�
    :class:`BboxTransformTo` is a transformation that linearly
    transforms points from the unit bounding box to a given
    :class:`Bbox`.
    cCsH|
jst
�
tj|�

|
|_|j|
�

d
|_d
|_d
S(s�
        Create a new :class:`BboxTransformTo` that linearly transforms
        points from the unit bounding box to *boxout*.
        N(	RBR�RE
RR|
RRRT
RA
(RR~
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRs

	


	
c

Csd
|jS(NsBboxTransformTo(%s)(
R|
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�+s
c
Cs�|jr�|j
j\}
}}}trN|d
ks?|d
krNtd�
�
ntj|d|
gd||gdddggtj�|_d|_
d
|_n|jS(Nis(Transforming to a singular bounding box.gg�?(R
R|
R�RDR
RIR�R�RT
RRA
(RR�
R�
R�
R�
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRB
/s
	







	

(
R,R=R>R�R:
RR�R
RB
RE
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�
s
	
		tBboxTransformToMaxOnlycBs5eZ
dZd
�ZeZd�Zejje_RS(s�
    :class:`BboxTransformTo` is a transformation that linearly
    transforms points from the unit bounding box to a given
    :class:`Bbox` with a fixed upper left of (0, 0).
    c

Csd
|jS(NsBboxTransformToMaxOnly(%s)(
R|
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�Ds
c
Cs�|jr�|j
j\}
}trH|
d
ks9|d
krHtd�
�
ntj|
ddgd|dgdddggtj�|_d|_
d
|_n|jS(Nis(Transforming to a singular bounding box.gg�?(R
R|
R^RDR
RIR�R�RT
RRA
(RR�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRB
Hs
	







	

(R,R=R>R�R
RB
RE
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�
>s

		tBboxTransformFromcBsDeZ
dZeZd
�Zd�ZeZd�Ze	jje_RS(sx
    :class:`BboxTransformFrom` linearly transforms points from a given
    :class:`Bbox` to the unit bounding box.
    cCsH|
jst
�
tj|�

|
|_|j|
�

d|_d|_dS(
N(	RBR�RE
RR{
RRRT
RA
(RR}
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR^s


	


	
c

Csd
|jS(NsBboxTransformFrom(%s)(
R{
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�gs
c
Cs�|jr�|j
j\}
}}}trN|d
ks?|d
krNtd�
�
nd|}d|}tj|d|
|gd|||gdddggtj�|_d|_
d
|_n|jS(Nis*Transforming from a singular bounding box.g�?g(R
R{
R�RDR
RIR�R�RT
RRA
(RR�
R�
R�
R�
R�
R�
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRB
ks
	











	

(
R,R=R>R�R:
RR�R
RB
RE
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�
Ws
				tScaledTranslationcBs>eZ
dZd
�Zd�ZeZd�Zejje_RS(s�
    A transformation that translates by *xt* and *yt*, after *xt* and *yt*
    have been transformad by the given transform *scale_trans*.
    cCsHtj
|�

|
|f|_||_|j|�

d|_d|_dS(
N(RE
Rt_tt_scale_transRRRT
RA
(Rtxttyttscale_trans((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s



	


	
c

Csd
|jf
S(NsScaledTranslation(%s)(
R�
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR��s
c
Cs||jru|j
j|j�
\}
}tjd
d|
gdd
|gddd
ggtj�|_d|_d|_	n|jS(Ng�?gi(
R
R�
R%
R�
RIR�R�RT
RRA
(RR�
R�
((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyRB
�s
	





	

(R,R=R>RR�R
RB
RE
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�
|s
			
tTransformedPathc
BsDeZ
dZd
�Zd�Zd�Zd�Zd�Zd�ZRS(s�
    A :class:`TransformedPath` caches a non-affine transformed copy of
    the :class:`~matplotlib.path.Path`.  This cached copy is
    automatically updated when the non-affine part of the transform
    changes.
    cCsWt|t
�st�
tj|�

|
|_||_|j|�

d
|_	d
|_
d
S(s�
        Create a new :class:`TransformedPath` from the given
        :class:`~matplotlib.path.Path` and :class:`Transform`.
        N(R�R
R�RRt_pathR
RRt_transformed_patht_transformed_points(RR�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�s

	
	


	
c

Cs}|j|j
@|j
ks(|jdkrp|jj|j�
|_t|jj|jj	�
d|jj
�|_nd
|_dS(Ni(R
R@R�
RR
R*
R�
RR!
R�R'
R�
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt_revalidate�s



c

Cs|j�
|j
|j�fS(
s3

        Return a copy of the child path, with the non-affine part of
        the transform already applied, along with the affine part of
        the path necessary to complete the transformation.  Unlike
        :meth:`get_transformed_path_and_affine`, no interpolation will
        be performed.
        (R�
R�
R#
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt!get_transformed_points_and_affine�s

c

Cs|j�
|j
|j�fS(
s�
        Return a copy of the child path, with the non-affine part of
        the transform already applied, along with the affine part of
        the path necessary to complete the transformation.
        (R�
R�
R#
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytget_transformed_path_and_affine�s

c

Cs_|j|j
@|j
ks(|jdkrC|jj|j�
|_nd
|_|jj|j�
S(sD
        Return a fully-transformed copy of the child path.
        iN(R
R@R�
RR
R*
R�
R)
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytget_fully_transformed_path�s


	
c


Cs
|jj
�S(
N(R
R#
(
R((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR#
�s
(	R,R=R>RR�
R�
R�
R�
R#
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyR�
�s
		
				g����MbP?gV瞯�<cCs�tj
|�
s tj
|
�
r+||fSt}|
|krS|
|}}
t}n|
|tt|�
t|
�
�|k
r�|d
kr�|}|}
q�||t|�
8}|
|t|
�
7}
n|r�|r�|
|}}
n||
fS(s�

    Ensure the endpoints of a range are finite and not too close together.

    "too close" means the interval is smaller than 'tiny' times
    the maximum absolute value.

    If they are too close, each will be moved by the 'expander'.
    If 'increasing' is True and vmin > vmax, they will be swapped,
    regardless of whether they are too close.

    If either is inf or -inf or nan, return - expander, expander.
    g(RItisfiniteRAR�R^R�(tvmintvmaxtexpanderttinyt
increasingtswapped((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytnonsingular�s
 





	
)


	



cCsF|\}}||kr0||
k
r0||
kpE||
k
oE||
kS(
N((R
R5R�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytinterval_contains�s
$
cCsF|\}}||kr0||
kr0||
kpE||
koE||
kS(
N((R
R5R�R�((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytinterval_contains_open	s
$
gtinchescCs�|d
kr#|t�j
||�S|
dkr>td�
�
n|dkra|d:}|d:}n|dks|td�
�
n|t|||
j�S(s

    Return a new transform with an added offset.
      args:
        trans is any transform
      kwargs:
        fig is the current figure; it can be None if units are 'dots'
        x, y give the offset
        units is 'inches', 'points' or 'dots'
    tdotss3For units of inches or points a fig kwarg is neededRKgR@R�
s%units must be dots, points, or inchesN(R�R_
RR
R�
tdpi_scale_trans(ttranstfigRoRrtunits((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pytoffset_copy	s











(5R>tnumpyRIRtmatplotlib._pathR
tnumpy.linalgRtweakrefRRGR;t	NameErrortsetsRtcbookR�RR�
RRRARDRN
tobjectRRERMR
R
R;
R@
RE
R�R"
Rg
Ru
Rn
Rv
Ry
R
Rz
R�
R�
R�
R�
R�
R�R�
R�
R�
RR�
(((sH/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/transforms.pyt<module>sZ












	����	+�L-_�/g:	_.	,(%B