Menu
▾
▴
[r6270]: / trunk / htdocs / matplotlib.transforms.html.template Maximize Restore History
3697 lines (3054 with data), 254.3 kB
@header@
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="heading">
<tr bgcolor="#7799ee">
<td valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"> <br><big><big><strong><a href="matplotlib.html"><font color="#ffffff">matplotlib</font></a>.transforms</strong></big></big></font></td
><td align=right valign=bottom
><font color="#ffffff" face="helvetica, arial"><a href=".">index</a><br><a href="file:/home/jdhunter/dev/lib64/python2.5/site-packages/matplotlib/transforms.py">/home/jdhunter/dev/lib64/python2.5/site-packages/matplotlib/transforms.py</a></font></td></tr></table>
<p><tt>matplotlib includes a framework for arbitrary geometric<br>
transformations that is used determine the final position of all<br>
elements drawn on the canvas.<br>
<br>
Transforms are composed into trees of :class:`<a href="#TransformNode">TransformNode</a>` objects<br>
whose actual value depends on their children. When the contents of<br>
children change, their parents are automatically invalidated. The<br>
next time an invalidated transform is accessed, it is recomputed to<br>
reflect those changes. This invalidation/caching approach prevents<br>
unnecessary recomputations of transforms, and contributes to better<br>
interactive performance.<br>
<br>
For example, here is a graph of the transform tree used to plot data<br>
to the graph:<br>
<br>
.. image:: ../_static/transforms.png<br>
<br>
The framework can be used for both affine and non-affine<br>
transformations. However, for speed, we want use the backend<br>
renderers to perform affine transformations whenever possible.<br>
Therefore, it is possible to perform just the affine or non-affine<br>
part of a transformation on a set of data. The affine is always<br>
assumed to occur after the non-affine. For any transform::<br>
<br>
full transform == non-affine part + affine part<br>
<br>
The backends are not expected to handle non-affine transformations<br>
themselves.</tt></p>
<p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#aa55cc">
<td colspan=3 valign=bottom> <br>
<font color="#fffff" face="helvetica, arial"><big><strong>Modules</strong></big></font></td></tr>
<tr><td bgcolor="#aa55cc"><tt> </tt></td><td> </td>
<td width="100%"><table width="100%" summary="list"><tr><td width="25%" valign=top><a href="matplotlib.cbook.html">matplotlib.cbook</a><br>
<a href="numpy.ma.html">numpy.ma</a><br>
</td><td width="25%" valign=top><a href="numpy.html">numpy</a><br>
<a href="sets.html">sets</a><br>
</td><td width="25%" valign=top><a href="warnings.html">warnings</a><br>
</td><td width="25%" valign=top></td></tr></table></td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ee77aa">
<td colspan=3 valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Classes</strong></big></font></td></tr>
<tr><td bgcolor="#ee77aa"><tt> </tt></td><td> </td>
<td width="100%"><dl>
<dt><font face="helvetica, arial"><a href="__builtin__.html#object">__builtin__.object</a>
</font></dt><dd>
<dl>
<dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#TransformNode">TransformNode</a>
</font></dt><dd>
<dl>
<dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#BboxBase">BboxBase</a>
</font></dt><dd>
<dl>
<dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#Bbox">Bbox</a>
</font></dt><dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#TransformedBbox">TransformedBbox</a>
</font></dt></dl>
</dd>
<dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#Transform">Transform</a>
</font></dt><dd>
<dl>
<dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#AffineBase">AffineBase</a>
</font></dt><dd>
<dl>
<dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>
</font></dt><dd>
<dl>
<dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#Affine2D">Affine2D</a>
</font></dt><dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#BboxTransform">BboxTransform</a>
</font></dt><dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#BboxTransformFrom">BboxTransformFrom</a>
</font></dt><dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#BboxTransformTo">BboxTransformTo</a>
</font></dt><dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#BlendedAffine2D">BlendedAffine2D</a>
</font></dt><dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#CompositeAffine2D">CompositeAffine2D</a>
</font></dt><dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#IdentityTransform">IdentityTransform</a>
</font></dt><dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#ScaledTranslation">ScaledTranslation</a>
</font></dt></dl>
</dd>
</dl>
</dd>
<dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#BlendedGenericTransform">BlendedGenericTransform</a>
</font></dt><dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#CompositeGenericTransform">CompositeGenericTransform</a>
</font></dt><dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#TransformWrapper">TransformWrapper</a>
</font></dt></dl>
</dd>
<dt><font face="helvetica, arial"><a href="matplotlib.transforms.html#TransformedPath">TransformedPath</a>
</font></dt></dl>
</dd>
</dl>
</dd>
</dl>
<p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="Affine2D">class <strong>Affine2D</strong></a>(<a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>A mutable 2D affine transformation.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#Affine2D">Affine2D</a></dd>
<dd><a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a></dd>
<dd><a href="matplotlib.transforms.html#AffineBase">AffineBase</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="Affine2D-__cmp__"><strong>__cmp__</strong></a>(self, other)</dt></dl>
<dl><dt><a name="Affine2D-__init__"><strong>__init__</strong></a>(self, matrix<font color="#909090">=None</font>)</dt><dd><tt>Initialize an Affine transform from a 3x3 numpy float array::<br>
<br>
a c e<br>
b d f<br>
0 0 1<br>
<br>
If matrix is None, initialize with the identity transform.</tt></dd></dl>
<dl><dt><a name="Affine2D-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="Affine2D-__str__"><strong>__str__</strong></a> = <a href="#Affine2D-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="Affine2D-clear"><strong>clear</strong></a>(self)</dt><dd><tt>Reset the underlying matrix to the identity transform.</tt></dd></dl>
<dl><dt><a name="Affine2D-get_matrix"><strong>get_matrix</strong></a>(self)</dt><dd><tt>Get the underlying transformation matrix as a 3x3 numpy array::<br>
<br>
a c e<br>
b d f<br>
0 0 1</tt></dd></dl>
<dl><dt><a name="Affine2D-rotate"><strong>rotate</strong></a>(self, theta)</dt><dd><tt>Add a rotation (in radians) to this transform in place.<br>
<br>
Returns self, so this method can easily be chained with more<br>
calls to :meth:`rotate`, :meth:`rotate_deg, :meth:`translate`<br>
and :meth:`scale`.</tt></dd></dl>
<dl><dt><a name="Affine2D-rotate_around"><strong>rotate_around</strong></a>(self, x, y, theta)</dt><dd><tt>Add a rotation (in radians) around the point (x, y) in place.<br>
<br>
Returns self, so this method can easily be chained with more<br>
calls to :meth:`rotate`, :meth:`rotate_deg, :meth:`translate`<br>
and :meth:`scale`.</tt></dd></dl>
<dl><dt><a name="Affine2D-rotate_deg"><strong>rotate_deg</strong></a>(self, degrees)</dt><dd><tt>Add a rotation (in degrees) to this transform in place.<br>
<br>
Returns self, so this method can easily be chained with more<br>
calls to :meth:`rotate`, :meth:`rotate_deg, :meth:`translate`<br>
and :meth:`scale`.</tt></dd></dl>
<dl><dt><a name="Affine2D-rotate_deg_around"><strong>rotate_deg_around</strong></a>(self, x, y, degrees)</dt><dd><tt>Add a rotation (in degrees) around the point (x, y) in place.<br>
<br>
Returns self, so this method can easily be chained with more<br>
calls to :meth:`rotate`, :meth:`rotate_deg, :meth:`translate`<br>
and :meth:`scale`.</tt></dd></dl>
<dl><dt><a name="Affine2D-scale"><strong>scale</strong></a>(self, sx, sy<font color="#909090">=None</font>)</dt><dd><tt>Adds a scale in place.<br>
<br>
If sy is None, the same scale is applied in both the x- and<br>
y-directions.<br>
<br>
Returns self, so this method can easily be chained with more<br>
calls to :meth:`rotate`, :meth:`rotate_deg, :meth:`translate`<br>
and :meth:`scale`.</tt></dd></dl>
<dl><dt><a name="Affine2D-set"><strong>set</strong></a>(self, other)</dt><dd><tt>Set this transformation from the frozen copy of another<br>
:class:`<a href="#Affine2DBase">Affine2DBase</a>` <a href="__builtin__.html#object">object</a>.</tt></dd></dl>
<dl><dt><a name="Affine2D-set_matrix"><strong>set_matrix</strong></a>(self, mtx)</dt><dd><tt>Set the underlying transformation matrix from a 3x3 numpy array::<br>
<br>
a c e<br>
b d f<br>
0 0 1</tt></dd></dl>
<dl><dt><a name="Affine2D-translate"><strong>translate</strong></a>(self, tx, ty)</dt><dd><tt>Adds a translation in place.<br>
<br>
Returns self, so this method can easily be chained with more<br>
calls to :meth:`rotate`, :meth:`rotate_deg, :meth:`translate`<br>
and :meth:`scale`.</tt></dd></dl>
<hr>
Static methods defined here:<br>
<dl><dt><a name="Affine2D-from_values"><strong>from_values</strong></a>(a, b, c, d, e, f)</dt><dd><tt>(staticmethod) Create a new <a href="#Affine2D">Affine2D</a> instance from the given<br>
values::<br>
<br>
a c e<br>
b d f<br>
0 0 1</tt></dd></dl>
<dl><dt><a name="Affine2D-identity"><strong>identity</strong></a>()</dt><dd><tt>(staticmethod) Return a new :class:`<a href="#Affine2D">Affine2D</a>` <a href="__builtin__.html#object">object</a> that is<br>
the identity transform.<br>
<br>
Unless this transform will be mutated later on, consider using<br>
the faster :class:`<a href="#IdentityTransform">IdentityTransform</a>` class instead.</tt></dd></dl>
<hr>
Data descriptors defined here:<br>
<dl><dt><strong>is_separable</strong></dt>
</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="Affine2D-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="Affine2D-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="Affine2D-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#Affine2D-inverted">inverted</a>().<a href="#Affine2D-transform">transform</a>(<a href="#Affine2D-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="Affine2D-to_values"><strong>to_values</strong></a>(self)</dt><dd><tt>Return the values of the matrix as a sequence (a,b,c,d,e,f)</tt></dd></dl>
<dl><dt><a name="Affine2D-transform"><strong>transform</strong></a>(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#Affine2D-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#Affine2D-transform_affine">transform_affine</a>(<a href="#Affine2D-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#Affine2D-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="Affine2D-transform_affine"><strong>transform_affine</strong></a> = transform(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#Affine2D-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#Affine2D-transform_affine">transform_affine</a>(<a href="#Affine2D-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#Affine2D-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="Affine2D-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Static methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="Affine2D-matrix_from_values"><strong>matrix_from_values</strong></a>(a, b, c, d, e, f)</dt><dd><tt>(staticmethod) Create a new transformation matrix as a 3x3<br>
numpy array of the form::<br>
<br>
a c e<br>
b d f<br>
0 0 1</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><strong>input_dims</strong> = 2</dl>
<dl><dt><strong>output_dims</strong> = 2</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><a name="Affine2D-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="Affine2D-transform_non_affine"><strong>transform_non_affine</strong></a>(self, points)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#Affine2D-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#Affine2D-transform_affine">transform_affine</a>(<a href="#Affine2D-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#Affine2D-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="Affine2D-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#Affine2D-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#Affine2D-transform_path_affine">transform_path_affine</a>(<a href="#Affine2D-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="Affine2D-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#Affine2D-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#Affine2D-transform_path_affine">transform_path_affine</a>(<a href="#Affine2D-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><strong>is_affine</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="Affine2D-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="Affine2D-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="Affine2D-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="Affine2D-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="Affine2D-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="Affine2D-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="Affine2D-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="Affine2D-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="Affine2DBase">class <strong>Affine2DBase</strong></a>(<a href="matplotlib.transforms.html#AffineBase">AffineBase</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>The base class of all 2D affine transformations.<br>
<br>
2D affine transformations are performed using a 3x3 numpy array::<br>
<br>
a c e<br>
b d f<br>
0 0 1<br>
<br>
This class provides the read-only interface. For a mutable 2D<br>
affine transformation, use :class:`<a href="#Affine2D">Affine2D</a>`.<br>
<br>
Subclasses of this class will generally only need to override a<br>
constructor and 'get_matrix' that generates a custom 3x3 matrix.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a></dd>
<dd><a href="matplotlib.transforms.html#AffineBase">AffineBase</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="Affine2DBase-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="Affine2DBase-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="Affine2DBase-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#Affine2DBase-inverted">inverted</a>().<a href="#Affine2DBase-transform">transform</a>(<a href="#Affine2DBase-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="Affine2DBase-to_values"><strong>to_values</strong></a>(self)</dt><dd><tt>Return the values of the matrix as a sequence (a,b,c,d,e,f)</tt></dd></dl>
<dl><dt><a name="Affine2DBase-transform"><strong>transform</strong></a>(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#Affine2DBase-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#Affine2DBase-transform_affine">transform_affine</a>(<a href="#Affine2DBase-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#Affine2DBase-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="Affine2DBase-transform_affine"><strong>transform_affine</strong></a> = <a href="#Affine2DBase-transform">transform</a>(self, points)</dt></dl>
<dl><dt><a name="Affine2DBase-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Static methods defined here:<br>
<dl><dt><a name="Affine2DBase-matrix_from_values"><strong>matrix_from_values</strong></a>(a, b, c, d, e, f)</dt><dd><tt>(staticmethod) Create a new transformation matrix as a 3x3<br>
numpy array of the form::<br>
<br>
a c e<br>
b d f<br>
0 0 1</tt></dd></dl>
<hr>
Data descriptors defined here:<br>
<dl><dt><strong>is_separable</strong></dt>
</dl>
<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>input_dims</strong> = 2</dl>
<dl><dt><strong>output_dims</strong> = 2</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><a name="Affine2DBase-__init__"><strong>__init__</strong></a>(self)</dt></dl>
<dl><dt><a name="Affine2DBase-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="Affine2DBase-get_matrix"><strong>get_matrix</strong></a>(self)</dt><dd><tt>Get the underlying transformation matrix as a numpy array.</tt></dd></dl>
<dl><dt><a name="Affine2DBase-transform_non_affine"><strong>transform_non_affine</strong></a>(self, points)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#Affine2DBase-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#Affine2DBase-transform_affine">transform_affine</a>(<a href="#Affine2DBase-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#Affine2DBase-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="Affine2DBase-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#Affine2DBase-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#Affine2DBase-transform_path_affine">transform_path_affine</a>(<a href="#Affine2DBase-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="Affine2DBase-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#Affine2DBase-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#Affine2DBase-transform_path_affine">transform_path_affine</a>(<a href="#Affine2DBase-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><strong>is_affine</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="Affine2DBase-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="Affine2DBase-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="Affine2DBase-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="Affine2DBase-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="Affine2DBase-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="Affine2DBase-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="Affine2DBase-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="Affine2DBase-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="AffineBase">class <strong>AffineBase</strong></a>(<a href="matplotlib.transforms.html#Transform">Transform</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>The base class of all affine transformations of any number of<br>
dimensions.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#AffineBase">AffineBase</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="AffineBase-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="AffineBase-__init__"><strong>__init__</strong></a>(self)</dt></dl>
<dl><dt><a name="AffineBase-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="AffineBase-get_matrix"><strong>get_matrix</strong></a>(self)</dt><dd><tt>Get the underlying transformation matrix as a numpy array.</tt></dd></dl>
<dl><dt><a name="AffineBase-transform_non_affine"><strong>transform_non_affine</strong></a>(self, points)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#AffineBase-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#AffineBase-transform_affine">transform_affine</a>(<a href="#AffineBase-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#AffineBase-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="AffineBase-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#AffineBase-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#AffineBase-transform_path_affine">transform_path_affine</a>(<a href="#AffineBase-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="AffineBase-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#AffineBase-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#AffineBase-transform_path_affine">transform_path_affine</a>(<a href="#AffineBase-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>is_affine</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="AffineBase-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="AffineBase-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="AffineBase-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#AffineBase-inverted">inverted</a>().<a href="#AffineBase-transform">transform</a>(<a href="#AffineBase-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="AffineBase-transform"><strong>transform</strong></a>(self, values)</dt><dd><tt>Performs the transformation on the given array of values.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="AffineBase-transform_affine"><strong>transform_affine</strong></a>(self, values)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#AffineBase-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#AffineBase-transform_affine">transform_affine</a>(<a href="#AffineBase-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#AffineBase-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="AffineBase-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<dl><dt><a name="AffineBase-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<dl><dt><strong>input_dims</strong> = None</dl>
<dl><dt><strong>is_separable</strong> = False</dl>
<dl><dt><strong>output_dims</strong> = None</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="AffineBase-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="AffineBase-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="AffineBase-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="AffineBase-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="AffineBase-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="AffineBase-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="Bbox">class <strong>Bbox</strong></a>(<a href="matplotlib.transforms.html#BboxBase">BboxBase</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>A mutable bounding box.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#Bbox">Bbox</a></dd>
<dd><a href="matplotlib.transforms.html#BboxBase">BboxBase</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="Bbox-__init__"><strong>__init__</strong></a>(self, points)</dt><dd><tt>points: a 2x2 numpy array of the form [[x0, y0], [x1, y1]]<br>
<br>
If you need to create a :class:`<a href="#Bbox">Bbox</a>` <a href="__builtin__.html#object">object</a> from another form<br>
of data, consider the static methods unit, from_bounds and<br>
from_extents.</tt></dd></dl>
<dl><dt><a name="Bbox-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="Bbox-__str__"><strong>__str__</strong></a> = <a href="#Bbox-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="Bbox-get_points"><strong>get_points</strong></a>(self)</dt><dd><tt>Get the points of the bounding box directly as a numpy array<br>
of the form: [[x0, y0], [x1, y1]].</tt></dd></dl>
<dl><dt><a name="Bbox-ignore"><strong>ignore</strong></a>(self, value)</dt><dd><tt>Set whether the existing bounds of the box should be ignored<br>
by subsequent calls to :meth:`update_from_data` or<br>
:meth:`update_from_data_xy`.<br>
<br>
value:<br>
<br>
- When True, subsequent calls to :meth:`update_from_data`<br>
will ignore the existing bounds of the :class:`<a href="#Bbox">Bbox</a>`.<br>
<br>
- When False, subsequent calls to :meth:`update_from_data`<br>
will include the existing bounds of the :class:`<a href="#Bbox">Bbox</a>`.</tt></dd></dl>
<dl><dt><a name="Bbox-set"><strong>set</strong></a>(self, other)</dt><dd><tt>Set this bounding box from the "frozen" bounds of another <a href="#Bbox">Bbox</a>.</tt></dd></dl>
<dl><dt><a name="Bbox-set_points"><strong>set_points</strong></a>(self, points)</dt><dd><tt>Set the points of the bounding box directly from a numpy array<br>
of the form: [[x0, y0], [x1, y1]]. No error checking<br>
is performed, as this method is mainly for internal use.</tt></dd></dl>
<dl><dt><a name="Bbox-update_from_data"><strong>update_from_data</strong></a>(self, x, y, ignore<font color="#909090">=None</font>)</dt><dd><tt>Update the bounds of the :class:`<a href="#Bbox">Bbox</a>` based on the passed in<br>
data.<br>
<br>
x: a numpy array of x-values<br>
<br>
y: a numpy array of y-values<br>
<br>
ignore:<br>
- when True, ignore the existing bounds of the <a href="#Bbox">Bbox</a>.<br>
- when False, include the existing bounds of the <a href="#Bbox">Bbox</a>.<br>
- when None, use the last value passed to :meth:`ignore`.</tt></dd></dl>
<dl><dt><a name="Bbox-update_from_data_xy"><strong>update_from_data_xy</strong></a>(self, xy, ignore<font color="#909090">=None</font>)</dt><dd><tt>Update the bounds of the :class:`<a href="#Bbox">Bbox</a>` based on the passed in<br>
data.<br>
<br>
xy: a numpy array of 2D points<br>
<br>
ignore:<br>
- when True, ignore the existing bounds of the <a href="#Bbox">Bbox</a>.<br>
- when False, include the existing bounds of the <a href="#Bbox">Bbox</a>.<br>
- when None, use the last value passed to :meth:`ignore`.</tt></dd></dl>
<hr>
Static methods defined here:<br>
<dl><dt><a name="Bbox-from_bounds"><strong>from_bounds</strong></a>(x0, y0, width, height)</dt><dd><tt>(staticmethod) Create a new :class:`<a href="#Bbox">Bbox</a>` from x0, y0, width<br>
and height.<br>
<br>
width and height may be negative.</tt></dd></dl>
<dl><dt><a name="Bbox-from_extents"><strong>from_extents</strong></a>(*args)</dt><dd><tt>(staticmethod) Create a new <a href="#Bbox">Bbox</a> from left, bottom, right and<br>
top.<br>
<br>
The y-axis increases upwards.</tt></dd></dl>
<dl><dt><a name="Bbox-unit"><strong>unit</strong></a>()</dt><dd><tt>(staticmethod) Create a new unit :class:`<a href="#Bbox">Bbox</a>` from (0, 0) to<br>
(1, 1).</tt></dd></dl>
<hr>
Data descriptors defined here:<br>
<dl><dt><strong>bounds</strong></dt>
</dl>
<dl><dt><strong>intervalx</strong></dt>
</dl>
<dl><dt><strong>intervaly</strong></dt>
</dl>
<dl><dt><strong>minpos</strong></dt>
</dl>
<dl><dt><strong>minposx</strong></dt>
</dl>
<dl><dt><strong>minposy</strong></dt>
</dl>
<dl><dt><strong>p0</strong></dt>
</dl>
<dl><dt><strong>p1</strong></dt>
</dl>
<dl><dt><strong>x0</strong></dt>
</dl>
<dl><dt><strong>x1</strong></dt>
</dl>
<dl><dt><strong>y0</strong></dt>
</dl>
<dl><dt><strong>y1</strong></dt>
</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#BboxBase">BboxBase</a>:<br>
<dl><dt><a name="Bbox-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="Bbox-anchored"><strong>anchored</strong></a>(self, c, container<font color="#909090">=None</font>)</dt><dd><tt>Return a copy of the <a href="#Bbox">Bbox</a>, shifted to position c within a<br>
container.<br>
<br>
c: may be either:<br>
<br>
* a sequence (cx, cy) where cx, cy range<br>
from 0 to 1, where 0 is left or bottom and 1 is right or top<br>
<br>
* a string:<br>
- C for centered<br>
- S for bottom-center<br>
- SE for bottom-left<br>
- E for left<br>
- etc.<br>
<br>
Optional argument *container* is the box within which the :class:`<a href="#Bbox">Bbox</a>`<br>
is positioned; it defaults to the initial :class:`<a href="#Bbox">Bbox</a>`.</tt></dd></dl>
<dl><dt><a name="Bbox-contains"><strong>contains</strong></a>(self, x, y)</dt><dd><tt>Returns True if (x, y) is a coordinate inside the bounding<br>
box or on its edge.</tt></dd></dl>
<dl><dt><a name="Bbox-containsx"><strong>containsx</strong></a>(self, x)</dt><dd><tt>Returns True if x is between or equal to :attr:`x0` and<br>
:attr:`x1`.</tt></dd></dl>
<dl><dt><a name="Bbox-containsy"><strong>containsy</strong></a>(self, y)</dt><dd><tt>Returns True if y is between or equal to :attr:`y0` and<br>
:attr:`y1`.</tt></dd></dl>
<dl><dt><a name="Bbox-corners"><strong>corners</strong></a>(self)</dt><dd><tt>Return an array of points which are the four corners of this<br>
rectangle. For example, if this :class:`<a href="#Bbox">Bbox</a>` is defined by<br>
the points (*a*, *b*) and (*c*, *d*), :meth:`corners` returns<br>
(*a*, *b*), (*a*, *d*), (*c*, *b*) and (*c*, *d*).</tt></dd></dl>
<dl><dt><a name="Bbox-count_contains"><strong>count_contains</strong></a>(self, vertices)</dt><dd><tt>Count the number of vertices contained in the <a href="#Bbox">Bbox</a>.<br>
<br>
vertices is a Nx2 numpy array.</tt></dd></dl>
<dl><dt><a name="Bbox-count_overlaps"><strong>count_overlaps</strong></a>(self, bboxes)</dt><dd><tt>Count the number of bounding boxes that overlap this one.<br>
<br>
bboxes is a sequence of :class:`<a href="#BboxBase">BboxBase</a>` objects</tt></dd></dl>
<dl><dt><a name="Bbox-expanded"><strong>expanded</strong></a>(self, sw, sh)</dt><dd><tt>Return a new :class:`<a href="#Bbox">Bbox</a>` which is this :class:`<a href="#Bbox">Bbox</a>`<br>
expanded around its center by the given factors *sw* and<br>
*sh*.</tt></dd></dl>
<dl><dt><a name="Bbox-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>:class:`<a href="#TransformNode">TransformNode</a>` is the base class for anything that<br>
participates in the transform tree and needs to invalidate its<br>
parents or be invalidated. This includes classes that are not<br>
really transforms, such as bounding boxes, since some transforms<br>
depend on bounding boxes to compute their values.</tt></dd></dl>
<dl><dt><a name="Bbox-fully_contains"><strong>fully_contains</strong></a>(self, x, y)</dt><dd><tt>Returns True if (x, y) is a coordinate inside the bounding<br>
box, but not on its edge.</tt></dd></dl>
<dl><dt><a name="Bbox-fully_containsx"><strong>fully_containsx</strong></a>(self, x)</dt><dd><tt>Returns True if x is between but not equal to :attr:`x0` and<br>
:attr:`x1`.</tt></dd></dl>
<dl><dt><a name="Bbox-fully_containsy"><strong>fully_containsy</strong></a>(self, y)</dt><dd><tt>Returns True if y is between but not equal to :attr:`y0` and<br>
:attr:`y1`.</tt></dd></dl>
<dl><dt><a name="Bbox-fully_overlaps"><strong>fully_overlaps</strong></a>(self, other)</dt><dd><tt>Returns True if this bounding box overlaps with the given<br>
bounding box *other*, but not on its edge alone.</tt></dd></dl>
<dl><dt><a name="Bbox-inverse_transformed"><strong>inverse_transformed</strong></a>(self, transform)</dt><dd><tt>Return a new :class:`<a href="#Bbox">Bbox</a>` <a href="__builtin__.html#object">object</a>, statically transformed by<br>
the inverse of the given transform.</tt></dd></dl>
<dl><dt><a name="Bbox-is_unit"><strong>is_unit</strong></a>(self)</dt><dd><tt>Returns True if the <a href="#Bbox">Bbox</a> is the unit bounding box from (0, 0)<br>
to (1, 1).</tt></dd></dl>
<dl><dt><a name="Bbox-overlaps"><strong>overlaps</strong></a>(self, other)</dt><dd><tt>Returns True if this bounding box overlaps with the given<br>
bounding box *other*.</tt></dd></dl>
<dl><dt><a name="Bbox-padded"><strong>padded</strong></a>(self, p)</dt><dd><tt>Return a new :class:`<a href="#Bbox">Bbox</a>` that is padded on all four sides by<br>
the given value.</tt></dd></dl>
<dl><dt><a name="Bbox-rotated"><strong>rotated</strong></a>(self, radians)</dt><dd><tt>Return a new bounding box that bounds a rotated version of<br>
this bounding box by the given radians. The new bounding box<br>
is still aligned with the axes, of course.</tt></dd></dl>
<dl><dt><a name="Bbox-shrunk"><strong>shrunk</strong></a>(self, mx, my)</dt><dd><tt>Return a copy of the :class:`<a href="#Bbox">Bbox</a>`, shurnk by the factor mx in<br>
the *x* direction and the factor my in the *y* direction. The<br>
lower left corner of the box remains unchanged. Normally mx<br>
and my will be less than 1, but this is not enforced.</tt></dd></dl>
<dl><dt><a name="Bbox-shrunk_to_aspect"><strong>shrunk_to_aspect</strong></a>(self, box_aspect, container<font color="#909090">=None</font>, fig_aspect<font color="#909090">=1.0</font>)</dt><dd><tt>Return a copy of the :class:`<a href="#Bbox">Bbox</a>`, shrunk so that it is as<br>
large as it can be while having the desired aspect ratio,<br>
*box_aspect*. If the box coordinates are relative---that<br>
is, fractions of a larger box such as a figure---then the<br>
physical aspect ratio of that figure is specified with<br>
*fig_aspect*, so that *box_aspect* can also be given as a<br>
ratio of the absolute dimensions, not the relative dimensions.</tt></dd></dl>
<dl><dt><a name="Bbox-splitx"><strong>splitx</strong></a>(self, *args)</dt><dd><tt>e.g., ``bbox.<a href="#Bbox-splitx">splitx</a>(f1, f2, ...)``<br>
<br>
Returns a list of new :class:`<a href="#Bbox">Bbox</a>` objects formed by<br>
splitting the original one with vertical lines at fractional<br>
positions *f1*, *f2*, ...</tt></dd></dl>
<dl><dt><a name="Bbox-splity"><strong>splity</strong></a>(self, *args)</dt><dd><tt>e.g., ``bbox.<a href="#Bbox-splitx">splitx</a>(f1, f2, ...)``<br>
<br>
Returns a list of new :class:`<a href="#Bbox">Bbox</a>` objects formed by<br>
splitting the original one with horizontal lines at fractional<br>
positions *f1*, *f2*, ...</tt></dd></dl>
<dl><dt><a name="Bbox-transformed"><strong>transformed</strong></a>(self, transform)</dt><dd><tt>Return a new :class:`<a href="#Bbox">Bbox</a>` <a href="__builtin__.html#object">object</a>, statically transformed by<br>
the given transform.</tt></dd></dl>
<dl><dt><a name="Bbox-translated"><strong>translated</strong></a>(self, tx, ty)</dt><dd><tt>Return a copy of the :class:`<a href="#Bbox">Bbox</a>`, statically translated by<br>
tx and ty.</tt></dd></dl>
<hr>
Static methods inherited from <a href="matplotlib.transforms.html#BboxBase">BboxBase</a>:<br>
<dl><dt><a name="Bbox-union"><strong>union</strong></a>(bboxes)</dt><dd><tt>Return a :class:`<a href="#Bbox">Bbox</a>` that contains all of the given bboxes.</tt></dd></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#BboxBase">BboxBase</a>:<br>
<dl><dt><strong>extents</strong></dt>
<dd><tt>(property) Returns (:attr:`x0`, :attr:`y0`, :attr:`x1`, :attr:`y1`).</tt></dd>
</dl>
<dl><dt><strong>height</strong></dt>
<dd><tt>(property) The height of the bounding box. It may be negative if :attr:`y1` <<br>
:attr:`y0`.</tt></dd>
</dl>
<dl><dt><strong>max</strong></dt>
<dd><tt>(property) :attr:`max` is the top-right corner of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>min</strong></dt>
<dd><tt>(property) :attr:`min` is the bottom-left corner of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>size</strong></dt>
<dd><tt>(property) The width and height of the bounding box. May be negative, in the same<br>
way as :attr:`width` and :attr:`height`.</tt></dd>
</dl>
<dl><dt><strong>width</strong></dt>
<dd><tt>(property) The width of the bounding box. It may be negative if :attr:`x1` <<br>
:attr:`x0`.</tt></dd>
</dl>
<dl><dt><strong>xmax</strong></dt>
<dd><tt>(property) :attr:`xmax` is the right edge of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>xmin</strong></dt>
<dd><tt>(property) :attr:`xmin` is the left edge of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>ymax</strong></dt>
<dd><tt>(property) :attr:`ymax` is the top edge of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>ymin</strong></dt>
<dd><tt>(property) :attr:`ymin` is the bottom edge of the bounding box.</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#BboxBase">BboxBase</a>:<br>
<dl><dt><strong>coefs</strong> = {'C': (0.5, 0.5), 'E': (1.0, 0.5), 'N': (0.5, 1.0), 'NE': (1.0, 1.0), 'NW': (0, 1.0), 'S': (0.5, 0), 'SE': (1.0, 0), 'SW': (0, 0), 'W': (0, 0.5)}</dl>
<dl><dt><strong>is_affine</strong> = True</dl>
<dl><dt><strong>is_bbox</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="Bbox-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="Bbox-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="Bbox-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="Bbox-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="Bbox-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="BboxBase">class <strong>BboxBase</strong></a>(<a href="matplotlib.transforms.html#TransformNode">TransformNode</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>This is the base class of all bounding boxes, and provides<br>
read-only access to its data. A mutable bounding box is provided<br>
by the :class:`<a href="#Bbox">Bbox</a>` class.<br>
<br>
The canonical representation is as two points, with no<br>
restrictions on their ordering. Convenience properties are<br>
provided to get the left, bottom, right and top edges and width<br>
and height, but these are not stored explicity.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#BboxBase">BboxBase</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="BboxBase-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="BboxBase-anchored"><strong>anchored</strong></a>(self, c, container<font color="#909090">=None</font>)</dt><dd><tt>Return a copy of the <a href="#Bbox">Bbox</a>, shifted to position c within a<br>
container.<br>
<br>
c: may be either:<br>
<br>
* a sequence (cx, cy) where cx, cy range<br>
from 0 to 1, where 0 is left or bottom and 1 is right or top<br>
<br>
* a string:<br>
- C for centered<br>
- S for bottom-center<br>
- SE for bottom-left<br>
- E for left<br>
- etc.<br>
<br>
Optional argument *container* is the box within which the :class:`<a href="#Bbox">Bbox</a>`<br>
is positioned; it defaults to the initial :class:`<a href="#Bbox">Bbox</a>`.</tt></dd></dl>
<dl><dt><a name="BboxBase-contains"><strong>contains</strong></a>(self, x, y)</dt><dd><tt>Returns True if (x, y) is a coordinate inside the bounding<br>
box or on its edge.</tt></dd></dl>
<dl><dt><a name="BboxBase-containsx"><strong>containsx</strong></a>(self, x)</dt><dd><tt>Returns True if x is between or equal to :attr:`x0` and<br>
:attr:`x1`.</tt></dd></dl>
<dl><dt><a name="BboxBase-containsy"><strong>containsy</strong></a>(self, y)</dt><dd><tt>Returns True if y is between or equal to :attr:`y0` and<br>
:attr:`y1`.</tt></dd></dl>
<dl><dt><a name="BboxBase-corners"><strong>corners</strong></a>(self)</dt><dd><tt>Return an array of points which are the four corners of this<br>
rectangle. For example, if this :class:`<a href="#Bbox">Bbox</a>` is defined by<br>
the points (*a*, *b*) and (*c*, *d*), :meth:`corners` returns<br>
(*a*, *b*), (*a*, *d*), (*c*, *b*) and (*c*, *d*).</tt></dd></dl>
<dl><dt><a name="BboxBase-count_contains"><strong>count_contains</strong></a>(self, vertices)</dt><dd><tt>Count the number of vertices contained in the <a href="#Bbox">Bbox</a>.<br>
<br>
vertices is a Nx2 numpy array.</tt></dd></dl>
<dl><dt><a name="BboxBase-count_overlaps"><strong>count_overlaps</strong></a>(self, bboxes)</dt><dd><tt>Count the number of bounding boxes that overlap this one.<br>
<br>
bboxes is a sequence of :class:`<a href="#BboxBase">BboxBase</a>` objects</tt></dd></dl>
<dl><dt><a name="BboxBase-expanded"><strong>expanded</strong></a>(self, sw, sh)</dt><dd><tt>Return a new :class:`<a href="#Bbox">Bbox</a>` which is this :class:`<a href="#Bbox">Bbox</a>`<br>
expanded around its center by the given factors *sw* and<br>
*sh*.</tt></dd></dl>
<dl><dt><a name="BboxBase-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>:class:`<a href="#TransformNode">TransformNode</a>` is the base class for anything that<br>
participates in the transform tree and needs to invalidate its<br>
parents or be invalidated. This includes classes that are not<br>
really transforms, such as bounding boxes, since some transforms<br>
depend on bounding boxes to compute their values.</tt></dd></dl>
<dl><dt><a name="BboxBase-fully_contains"><strong>fully_contains</strong></a>(self, x, y)</dt><dd><tt>Returns True if (x, y) is a coordinate inside the bounding<br>
box, but not on its edge.</tt></dd></dl>
<dl><dt><a name="BboxBase-fully_containsx"><strong>fully_containsx</strong></a>(self, x)</dt><dd><tt>Returns True if x is between but not equal to :attr:`x0` and<br>
:attr:`x1`.</tt></dd></dl>
<dl><dt><a name="BboxBase-fully_containsy"><strong>fully_containsy</strong></a>(self, y)</dt><dd><tt>Returns True if y is between but not equal to :attr:`y0` and<br>
:attr:`y1`.</tt></dd></dl>
<dl><dt><a name="BboxBase-fully_overlaps"><strong>fully_overlaps</strong></a>(self, other)</dt><dd><tt>Returns True if this bounding box overlaps with the given<br>
bounding box *other*, but not on its edge alone.</tt></dd></dl>
<dl><dt><a name="BboxBase-get_points"><strong>get_points</strong></a>(self)</dt></dl>
<dl><dt><a name="BboxBase-inverse_transformed"><strong>inverse_transformed</strong></a>(self, transform)</dt><dd><tt>Return a new :class:`<a href="#Bbox">Bbox</a>` <a href="__builtin__.html#object">object</a>, statically transformed by<br>
the inverse of the given transform.</tt></dd></dl>
<dl><dt><a name="BboxBase-is_unit"><strong>is_unit</strong></a>(self)</dt><dd><tt>Returns True if the <a href="#Bbox">Bbox</a> is the unit bounding box from (0, 0)<br>
to (1, 1).</tt></dd></dl>
<dl><dt><a name="BboxBase-overlaps"><strong>overlaps</strong></a>(self, other)</dt><dd><tt>Returns True if this bounding box overlaps with the given<br>
bounding box *other*.</tt></dd></dl>
<dl><dt><a name="BboxBase-padded"><strong>padded</strong></a>(self, p)</dt><dd><tt>Return a new :class:`<a href="#Bbox">Bbox</a>` that is padded on all four sides by<br>
the given value.</tt></dd></dl>
<dl><dt><a name="BboxBase-rotated"><strong>rotated</strong></a>(self, radians)</dt><dd><tt>Return a new bounding box that bounds a rotated version of<br>
this bounding box by the given radians. The new bounding box<br>
is still aligned with the axes, of course.</tt></dd></dl>
<dl><dt><a name="BboxBase-shrunk"><strong>shrunk</strong></a>(self, mx, my)</dt><dd><tt>Return a copy of the :class:`<a href="#Bbox">Bbox</a>`, shurnk by the factor mx in<br>
the *x* direction and the factor my in the *y* direction. The<br>
lower left corner of the box remains unchanged. Normally mx<br>
and my will be less than 1, but this is not enforced.</tt></dd></dl>
<dl><dt><a name="BboxBase-shrunk_to_aspect"><strong>shrunk_to_aspect</strong></a>(self, box_aspect, container<font color="#909090">=None</font>, fig_aspect<font color="#909090">=1.0</font>)</dt><dd><tt>Return a copy of the :class:`<a href="#Bbox">Bbox</a>`, shrunk so that it is as<br>
large as it can be while having the desired aspect ratio,<br>
*box_aspect*. If the box coordinates are relative---that<br>
is, fractions of a larger box such as a figure---then the<br>
physical aspect ratio of that figure is specified with<br>
*fig_aspect*, so that *box_aspect* can also be given as a<br>
ratio of the absolute dimensions, not the relative dimensions.</tt></dd></dl>
<dl><dt><a name="BboxBase-splitx"><strong>splitx</strong></a>(self, *args)</dt><dd><tt>e.g., ``bbox.<a href="#BboxBase-splitx">splitx</a>(f1, f2, ...)``<br>
<br>
Returns a list of new :class:`<a href="#Bbox">Bbox</a>` objects formed by<br>
splitting the original one with vertical lines at fractional<br>
positions *f1*, *f2*, ...</tt></dd></dl>
<dl><dt><a name="BboxBase-splity"><strong>splity</strong></a>(self, *args)</dt><dd><tt>e.g., ``bbox.<a href="#BboxBase-splitx">splitx</a>(f1, f2, ...)``<br>
<br>
Returns a list of new :class:`<a href="#Bbox">Bbox</a>` objects formed by<br>
splitting the original one with horizontal lines at fractional<br>
positions *f1*, *f2*, ...</tt></dd></dl>
<dl><dt><a name="BboxBase-transformed"><strong>transformed</strong></a>(self, transform)</dt><dd><tt>Return a new :class:`<a href="#Bbox">Bbox</a>` <a href="__builtin__.html#object">object</a>, statically transformed by<br>
the given transform.</tt></dd></dl>
<dl><dt><a name="BboxBase-translated"><strong>translated</strong></a>(self, tx, ty)</dt><dd><tt>Return a copy of the :class:`<a href="#Bbox">Bbox</a>`, statically translated by<br>
tx and ty.</tt></dd></dl>
<hr>
Static methods defined here:<br>
<dl><dt><a name="BboxBase-union"><strong>union</strong></a>(bboxes)</dt><dd><tt>Return a :class:`<a href="#Bbox">Bbox</a>` that contains all of the given bboxes.</tt></dd></dl>
<hr>
Data descriptors defined here:<br>
<dl><dt><strong>bounds</strong></dt>
<dd><tt>(property) Returns (:attr:`x0`, :attr:`y0`, :attr:`width`, :attr:`height`).</tt></dd>
</dl>
<dl><dt><strong>extents</strong></dt>
<dd><tt>(property) Returns (:attr:`x0`, :attr:`y0`, :attr:`x1`, :attr:`y1`).</tt></dd>
</dl>
<dl><dt><strong>height</strong></dt>
<dd><tt>(property) The height of the bounding box. It may be negative if :attr:`y1` <<br>
:attr:`y0`.</tt></dd>
</dl>
<dl><dt><strong>intervalx</strong></dt>
<dd><tt>(property) :attr:`intervalx` is the pair of *x* coordinates that define the<br>
bounding box. It is not guaranteed to be sorted from left to right.</tt></dd>
</dl>
<dl><dt><strong>intervaly</strong></dt>
<dd><tt>(property) :attr:`intervaly` is the pair of *y* coordinates that define the<br>
bounding box. It is not guaranteed to be sorted from bottom to top.</tt></dd>
</dl>
<dl><dt><strong>max</strong></dt>
<dd><tt>(property) :attr:`max` is the top-right corner of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>min</strong></dt>
<dd><tt>(property) :attr:`min` is the bottom-left corner of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>p0</strong></dt>
<dd><tt>(property) :attr:`p0` is the first pair of (*x*, *y*) coordinates that<br>
define the bounding box. It is not guaranteed to be the bottom-left<br>
corner. For that, use :attr:`min`.</tt></dd>
</dl>
<dl><dt><strong>p1</strong></dt>
<dd><tt>(property) :attr:`p1` is the second pair of (*x*, *y*) coordinates that<br>
define the bounding box. It is not guaranteed to be the top-right<br>
corner. For that, use :attr:`max`.</tt></dd>
</dl>
<dl><dt><strong>size</strong></dt>
<dd><tt>(property) The width and height of the bounding box. May be negative, in the same<br>
way as :attr:`width` and :attr:`height`.</tt></dd>
</dl>
<dl><dt><strong>width</strong></dt>
<dd><tt>(property) The width of the bounding box. It may be negative if :attr:`x1` <<br>
:attr:`x0`.</tt></dd>
</dl>
<dl><dt><strong>x0</strong></dt>
<dd><tt>(property) :attr:`x0` is the first of the pair of *x* coordinates that<br>
define the bounding box. :attr:`x0` is not guaranteed to be<br>
less than :attr:`x1`. If you require that, use :attr:`xmin`.</tt></dd>
</dl>
<dl><dt><strong>x1</strong></dt>
<dd><tt>(property) :attr:`x1` is the second of the pair of *x* coordinates that<br>
define the bounding box. :attr:`x1` is not guaranteed to be<br>
greater than :attr:`x0`. If you require that, use :attr:`xmax`.</tt></dd>
</dl>
<dl><dt><strong>xmax</strong></dt>
<dd><tt>(property) :attr:`xmax` is the right edge of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>xmin</strong></dt>
<dd><tt>(property) :attr:`xmin` is the left edge of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>y0</strong></dt>
<dd><tt>(property) :attr:`y0` is the first of the pair of *y* coordinates that<br>
define the bounding box. :attr:`y0` is not guaranteed to be<br>
less than :attr:`y1`. If you require that, use :attr:`ymin`.</tt></dd>
</dl>
<dl><dt><strong>y1</strong></dt>
<dd><tt>(property) :attr:`y1` is the second of the pair of *y* coordinates that<br>
define the bounding box. :attr:`y1` is not guaranteed to be<br>
greater than :attr:`y0`. If you require that, use :attr:`ymax`.</tt></dd>
</dl>
<dl><dt><strong>ymax</strong></dt>
<dd><tt>(property) :attr:`ymax` is the top edge of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>ymin</strong></dt>
<dd><tt>(property) :attr:`ymin` is the bottom edge of the bounding box.</tt></dd>
</dl>
<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>coefs</strong> = {'C': (0.5, 0.5), 'E': (1.0, 0.5), 'N': (0.5, 1.0), 'NE': (1.0, 1.0), 'NW': (0, 1.0), 'S': (0.5, 0), 'SE': (1.0, 0), 'SW': (0, 0), 'W': (0, 0.5)}</dl>
<dl><dt><strong>is_affine</strong> = True</dl>
<dl><dt><strong>is_bbox</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="BboxBase-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="BboxBase-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="BboxBase-__init__"><strong>__init__</strong></a>(self)</dt><dd><tt>Creates a new <a href="#TransformNode">TransformNode</a>.</tt></dd></dl>
<dl><dt><a name="BboxBase-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="BboxBase-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="BboxBase-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="BboxTransform">class <strong>BboxTransform</strong></a>(<a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt><a href="#BboxTransform">BboxTransform</a> linearly transforms points from one <a href="#Bbox">Bbox</a> to another <a href="#Bbox">Bbox</a>.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#BboxTransform">BboxTransform</a></dd>
<dd><a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a></dd>
<dd><a href="matplotlib.transforms.html#AffineBase">AffineBase</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="BboxTransform-__init__"><strong>__init__</strong></a>(self, boxin, boxout)</dt><dd><tt>Create a new <a href="#BboxTransform">BboxTransform</a> that linearly transforms points<br>
from boxin to boxout.</tt></dd></dl>
<dl><dt><a name="BboxTransform-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="BboxTransform-__str__"><strong>__str__</strong></a> = <a href="#BboxTransform-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="BboxTransform-get_matrix"><strong>get_matrix</strong></a>(self)</dt><dd><tt>Get the underlying transformation matrix as a numpy array.</tt></dd></dl>
<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>is_separable</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="BboxTransform-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="BboxTransform-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="BboxTransform-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#BboxTransform-inverted">inverted</a>().<a href="#BboxTransform-transform">transform</a>(<a href="#BboxTransform-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="BboxTransform-to_values"><strong>to_values</strong></a>(self)</dt><dd><tt>Return the values of the matrix as a sequence (a,b,c,d,e,f)</tt></dd></dl>
<dl><dt><a name="BboxTransform-transform"><strong>transform</strong></a>(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#BboxTransform-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BboxTransform-transform_affine">transform_affine</a>(<a href="#BboxTransform-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#BboxTransform-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BboxTransform-transform_affine"><strong>transform_affine</strong></a> = transform(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#BboxTransform-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BboxTransform-transform_affine">transform_affine</a>(<a href="#BboxTransform-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#BboxTransform-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BboxTransform-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Static methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="BboxTransform-matrix_from_values"><strong>matrix_from_values</strong></a>(a, b, c, d, e, f)</dt><dd><tt>(staticmethod) Create a new transformation matrix as a 3x3<br>
numpy array of the form::<br>
<br>
a c e<br>
b d f<br>
0 0 1</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><strong>input_dims</strong> = 2</dl>
<dl><dt><strong>output_dims</strong> = 2</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><a name="BboxTransform-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="BboxTransform-transform_non_affine"><strong>transform_non_affine</strong></a>(self, points)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#BboxTransform-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BboxTransform-transform_affine">transform_affine</a>(<a href="#BboxTransform-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#BboxTransform-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BboxTransform-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#BboxTransform-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#BboxTransform-transform_path_affine">transform_path_affine</a>(<a href="#BboxTransform-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="BboxTransform-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#BboxTransform-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#BboxTransform-transform_path_affine">transform_path_affine</a>(<a href="#BboxTransform-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><strong>is_affine</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="BboxTransform-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="BboxTransform-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="BboxTransform-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="BboxTransform-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="BboxTransform-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="BboxTransform-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="BboxTransform-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="BboxTransform-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="BboxTransformFrom">class <strong>BboxTransformFrom</strong></a>(<a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt><a href="#BboxTransform">BboxTransform</a> linearly transforms points from a given<br>
:class:`<a href="#Bbox">Bbox</a>` to the unit bounding box.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#BboxTransformFrom">BboxTransformFrom</a></dd>
<dd><a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a></dd>
<dd><a href="matplotlib.transforms.html#AffineBase">AffineBase</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="BboxTransformFrom-__init__"><strong>__init__</strong></a>(self, boxin)</dt></dl>
<dl><dt><a name="BboxTransformFrom-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="BboxTransformFrom-__str__"><strong>__str__</strong></a> = <a href="#BboxTransformFrom-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="BboxTransformFrom-get_matrix"><strong>get_matrix</strong></a>(self)</dt><dd><tt>Get the underlying transformation matrix as a numpy array.</tt></dd></dl>
<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>is_separable</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="BboxTransformFrom-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="BboxTransformFrom-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#BboxTransformFrom-inverted">inverted</a>().<a href="#BboxTransformFrom-transform">transform</a>(<a href="#BboxTransformFrom-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-to_values"><strong>to_values</strong></a>(self)</dt><dd><tt>Return the values of the matrix as a sequence (a,b,c,d,e,f)</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-transform"><strong>transform</strong></a>(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#BboxTransformFrom-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BboxTransformFrom-transform_affine">transform_affine</a>(<a href="#BboxTransformFrom-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#BboxTransformFrom-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-transform_affine"><strong>transform_affine</strong></a> = transform(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#BboxTransformFrom-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BboxTransformFrom-transform_affine">transform_affine</a>(<a href="#BboxTransformFrom-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#BboxTransformFrom-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Static methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="BboxTransformFrom-matrix_from_values"><strong>matrix_from_values</strong></a>(a, b, c, d, e, f)</dt><dd><tt>(staticmethod) Create a new transformation matrix as a 3x3<br>
numpy array of the form::<br>
<br>
a c e<br>
b d f<br>
0 0 1</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><strong>input_dims</strong> = 2</dl>
<dl><dt><strong>output_dims</strong> = 2</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><a name="BboxTransformFrom-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-transform_non_affine"><strong>transform_non_affine</strong></a>(self, points)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#BboxTransformFrom-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BboxTransformFrom-transform_affine">transform_affine</a>(<a href="#BboxTransformFrom-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#BboxTransformFrom-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#BboxTransformFrom-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#BboxTransformFrom-transform_path_affine">transform_path_affine</a>(<a href="#BboxTransformFrom-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#BboxTransformFrom-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#BboxTransformFrom-transform_path_affine">transform_path_affine</a>(<a href="#BboxTransformFrom-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><strong>is_affine</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="BboxTransformFrom-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="BboxTransformFrom-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="BboxTransformFrom-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="BboxTransformFrom-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="BboxTransformTo">class <strong>BboxTransformTo</strong></a>(<a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt><a href="#BboxTransformTo">BboxTransformTo</a> is a transformation that linearly transforms<br>
points from the unit bounding box to a given :class:`<a href="#Bbox">Bbox</a>`.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#BboxTransformTo">BboxTransformTo</a></dd>
<dd><a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a></dd>
<dd><a href="matplotlib.transforms.html#AffineBase">AffineBase</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="BboxTransformTo-__init__"><strong>__init__</strong></a>(self, boxout)</dt><dd><tt>Create a new :class:`<a href="#BboxTransformTo">BboxTransformTo</a>` that linearly transforms<br>
points from the unit bounding box to boxout.</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="BboxTransformTo-__str__"><strong>__str__</strong></a> = <a href="#BboxTransformTo-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="BboxTransformTo-get_matrix"><strong>get_matrix</strong></a>(self)</dt><dd><tt>Get the underlying transformation matrix as a numpy array.</tt></dd></dl>
<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>is_separable</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="BboxTransformTo-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="BboxTransformTo-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#BboxTransformTo-inverted">inverted</a>().<a href="#BboxTransformTo-transform">transform</a>(<a href="#BboxTransformTo-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-to_values"><strong>to_values</strong></a>(self)</dt><dd><tt>Return the values of the matrix as a sequence (a,b,c,d,e,f)</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-transform"><strong>transform</strong></a>(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#BboxTransformTo-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BboxTransformTo-transform_affine">transform_affine</a>(<a href="#BboxTransformTo-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#BboxTransformTo-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-transform_affine"><strong>transform_affine</strong></a> = transform(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#BboxTransformTo-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BboxTransformTo-transform_affine">transform_affine</a>(<a href="#BboxTransformTo-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#BboxTransformTo-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Static methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="BboxTransformTo-matrix_from_values"><strong>matrix_from_values</strong></a>(a, b, c, d, e, f)</dt><dd><tt>(staticmethod) Create a new transformation matrix as a 3x3<br>
numpy array of the form::<br>
<br>
a c e<br>
b d f<br>
0 0 1</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><strong>input_dims</strong> = 2</dl>
<dl><dt><strong>output_dims</strong> = 2</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><a name="BboxTransformTo-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-transform_non_affine"><strong>transform_non_affine</strong></a>(self, points)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#BboxTransformTo-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BboxTransformTo-transform_affine">transform_affine</a>(<a href="#BboxTransformTo-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#BboxTransformTo-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#BboxTransformTo-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#BboxTransformTo-transform_path_affine">transform_path_affine</a>(<a href="#BboxTransformTo-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#BboxTransformTo-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#BboxTransformTo-transform_path_affine">transform_path_affine</a>(<a href="#BboxTransformTo-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><strong>is_affine</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="BboxTransformTo-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="BboxTransformTo-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="BboxTransformTo-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="BboxTransformTo-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="BlendedAffine2D">class <strong>BlendedAffine2D</strong></a>(<a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>A "blended" transform uses one transform for the x-direction, and<br>
another transform for the y-direction.<br>
<br>
This version is an optimization for the case where both child<br>
transforms are of type <a href="#Affine2DBase">Affine2DBase</a>.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#BlendedAffine2D">BlendedAffine2D</a></dd>
<dd><a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a></dd>
<dd><a href="matplotlib.transforms.html#AffineBase">AffineBase</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="BlendedAffine2D-__init__"><strong>__init__</strong></a>(self, x_transform, y_transform)</dt><dd><tt>Create a new "blended" transform using x_transform to<br>
transform the x-axis and y_transform to transform the y_axis.<br>
<br>
Both x_transform and y_transform must be 2D affine transforms.<br>
<br>
You will generally not call this constructor directly but use<br>
the :func:`blended_transform_factory` function instead, which<br>
can determine automatically which kind of blended transform to<br>
create.</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="BlendedAffine2D-__str__"><strong>__str__</strong></a> = <a href="#BlendedAffine2D-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="BlendedAffine2D-get_matrix"><strong>get_matrix</strong></a>(self)</dt><dd><tt>Get the underlying transformation matrix as a numpy array.</tt></dd></dl>
<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>is_separable</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="BlendedAffine2D-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="BlendedAffine2D-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#BlendedAffine2D-inverted">inverted</a>().<a href="#BlendedAffine2D-transform">transform</a>(<a href="#BlendedAffine2D-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-to_values"><strong>to_values</strong></a>(self)</dt><dd><tt>Return the values of the matrix as a sequence (a,b,c,d,e,f)</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-transform"><strong>transform</strong></a>(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#BlendedAffine2D-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BlendedAffine2D-transform_affine">transform_affine</a>(<a href="#BlendedAffine2D-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#BlendedAffine2D-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-transform_affine"><strong>transform_affine</strong></a> = transform(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#BlendedAffine2D-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BlendedAffine2D-transform_affine">transform_affine</a>(<a href="#BlendedAffine2D-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#BlendedAffine2D-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Static methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="BlendedAffine2D-matrix_from_values"><strong>matrix_from_values</strong></a>(a, b, c, d, e, f)</dt><dd><tt>(staticmethod) Create a new transformation matrix as a 3x3<br>
numpy array of the form::<br>
<br>
a c e<br>
b d f<br>
0 0 1</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><strong>input_dims</strong> = 2</dl>
<dl><dt><strong>output_dims</strong> = 2</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><a name="BlendedAffine2D-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-transform_non_affine"><strong>transform_non_affine</strong></a>(self, points)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#BlendedAffine2D-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BlendedAffine2D-transform_affine">transform_affine</a>(<a href="#BlendedAffine2D-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#BlendedAffine2D-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#BlendedAffine2D-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#BlendedAffine2D-transform_path_affine">transform_path_affine</a>(<a href="#BlendedAffine2D-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#BlendedAffine2D-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#BlendedAffine2D-transform_path_affine">transform_path_affine</a>(<a href="#BlendedAffine2D-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><strong>is_affine</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="BlendedAffine2D-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="BlendedAffine2D-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="BlendedAffine2D-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="BlendedAffine2D-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="BlendedGenericTransform">class <strong>BlendedGenericTransform</strong></a>(<a href="matplotlib.transforms.html#Transform">Transform</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>A "blended" transform uses one transform for the x-direction, and<br>
another transform for the y-direction.<br>
<br>
This "generic" version can handle any given child transform in the<br>
x- and y-directions.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#BlendedGenericTransform">BlendedGenericTransform</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="BlendedGenericTransform-__init__"><strong>__init__</strong></a>(self, x_transform, y_transform)</dt><dd><tt>Create a new "blended" transform using x_transform to<br>
transform the x-axis and y_transform to transform the y_axis.<br>
<br>
You will generally not call this constructor directly but use<br>
the :func:`blended_transform_factory` function instead, which<br>
can determine automatically which kind of blended transform to<br>
create.</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="BlendedGenericTransform-__str__"><strong>__str__</strong></a> = <a href="#BlendedGenericTransform-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="BlendedGenericTransform-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#BlendedGenericTransform-inverted">inverted</a>().<a href="#BlendedGenericTransform-transform">transform</a>(<a href="#BlendedGenericTransform-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-transform"><strong>transform</strong></a>(self, points)</dt><dd><tt>Performs the transformation on the given array of values.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-transform_affine"><strong>transform_affine</strong></a>(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#BlendedGenericTransform-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BlendedGenericTransform-transform_affine">transform_affine</a>(<a href="#BlendedGenericTransform-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#BlendedGenericTransform-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-transform_non_affine"><strong>transform_non_affine</strong></a>(self, points)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#BlendedGenericTransform-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#BlendedGenericTransform-transform_affine">transform_affine</a>(<a href="#BlendedGenericTransform-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#BlendedGenericTransform-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<hr>
Data descriptors defined here:<br>
<dl><dt><strong>is_affine</strong></dt>
</dl>
<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>input_dims</strong> = 2</dl>
<dl><dt><strong>is_separable</strong> = True</dl>
<dl><dt><strong>output_dims</strong> = 2</dl>
<dl><dt><strong>pass_through</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="BlendedGenericTransform-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt><dd><tt>Used by C/C++ -based backends to get at the array matrix data.</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#BlendedGenericTransform-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#BlendedGenericTransform-transform_path_affine">transform_path_affine</a>(<a href="#BlendedGenericTransform-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#BlendedGenericTransform-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#BlendedGenericTransform-transform_path_affine">transform_path_affine</a>(<a href="#BlendedGenericTransform-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="BlendedGenericTransform-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="BlendedGenericTransform-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="BlendedGenericTransform-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="BlendedGenericTransform-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="CompositeAffine2D">class <strong>CompositeAffine2D</strong></a>(<a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>A composite transform formed by applying transform a then transform b.<br>
<br>
This version is an optimization that handles the case where both a<br>
and b are 2D affines.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#CompositeAffine2D">CompositeAffine2D</a></dd>
<dd><a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a></dd>
<dd><a href="matplotlib.transforms.html#AffineBase">AffineBase</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="CompositeAffine2D-__init__"><strong>__init__</strong></a>(self, a, b)</dt><dd><tt>Create a new composite transform that is the result of<br>
applying transform a then transform b.<br>
<br>
Both a and b must be instances of :class:`<a href="#Affine2DBase">Affine2DBase</a>`.<br>
<br>
You will generally not call this constructor directly but use<br>
the :func:`composite_transform_factory` function instead,<br>
which can automatically choose the best kind of composite<br>
transform instance to create.</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="CompositeAffine2D-__str__"><strong>__str__</strong></a> = <a href="#CompositeAffine2D-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="CompositeAffine2D-get_matrix"><strong>get_matrix</strong></a>(self)</dt><dd><tt>Get the underlying transformation matrix as a numpy array.</tt></dd></dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="CompositeAffine2D-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="CompositeAffine2D-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#CompositeAffine2D-inverted">inverted</a>().<a href="#CompositeAffine2D-transform">transform</a>(<a href="#CompositeAffine2D-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-to_values"><strong>to_values</strong></a>(self)</dt><dd><tt>Return the values of the matrix as a sequence (a,b,c,d,e,f)</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-transform"><strong>transform</strong></a>(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#CompositeAffine2D-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#CompositeAffine2D-transform_affine">transform_affine</a>(<a href="#CompositeAffine2D-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#CompositeAffine2D-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-transform_affine"><strong>transform_affine</strong></a> = transform(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#CompositeAffine2D-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#CompositeAffine2D-transform_affine">transform_affine</a>(<a href="#CompositeAffine2D-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#CompositeAffine2D-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Static methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="CompositeAffine2D-matrix_from_values"><strong>matrix_from_values</strong></a>(a, b, c, d, e, f)</dt><dd><tt>(staticmethod) Create a new transformation matrix as a 3x3<br>
numpy array of the form::<br>
<br>
a c e<br>
b d f<br>
0 0 1</tt></dd></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><strong>is_separable</strong></dt>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><strong>input_dims</strong> = 2</dl>
<dl><dt><strong>output_dims</strong> = 2</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><a name="CompositeAffine2D-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-transform_non_affine"><strong>transform_non_affine</strong></a>(self, points)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#CompositeAffine2D-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#CompositeAffine2D-transform_affine">transform_affine</a>(<a href="#CompositeAffine2D-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#CompositeAffine2D-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#CompositeAffine2D-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#CompositeAffine2D-transform_path_affine">transform_path_affine</a>(<a href="#CompositeAffine2D-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#CompositeAffine2D-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#CompositeAffine2D-transform_path_affine">transform_path_affine</a>(<a href="#CompositeAffine2D-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><strong>is_affine</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="CompositeAffine2D-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="CompositeAffine2D-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="CompositeAffine2D-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="CompositeAffine2D-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="CompositeGenericTransform">class <strong>CompositeGenericTransform</strong></a>(<a href="matplotlib.transforms.html#Transform">Transform</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>A composite transform formed by applying transform a then transform b.<br>
<br>
This "generic" version can handle any two arbitrary transformations.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#CompositeGenericTransform">CompositeGenericTransform</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="CompositeGenericTransform-__init__"><strong>__init__</strong></a>(self, a, b)</dt><dd><tt>Create a new composite transform that is the result of<br>
applying transform a then transform b.<br>
<br>
You will generally not call this constructor directly but use<br>
the :func:`composite_transform_factory` function instead,<br>
which can automatically choose the best kind of composite<br>
transform instance to create.</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="CompositeGenericTransform-__str__"><strong>__str__</strong></a> = <a href="#CompositeGenericTransform-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="CompositeGenericTransform-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#CompositeGenericTransform-inverted">inverted</a>().<a href="#CompositeGenericTransform-transform">transform</a>(<a href="#CompositeGenericTransform-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-transform"><strong>transform</strong></a>(self, points)</dt><dd><tt>Performs the transformation on the given array of values.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-transform_affine"><strong>transform_affine</strong></a>(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#CompositeGenericTransform-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#CompositeGenericTransform-transform_affine">transform_affine</a>(<a href="#CompositeGenericTransform-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#CompositeGenericTransform-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-transform_non_affine"><strong>transform_non_affine</strong></a>(self, points)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#CompositeGenericTransform-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#CompositeGenericTransform-transform_affine">transform_affine</a>(<a href="#CompositeGenericTransform-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#CompositeGenericTransform-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#CompositeGenericTransform-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#CompositeGenericTransform-transform_path_affine">transform_path_affine</a>(<a href="#CompositeGenericTransform-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#CompositeGenericTransform-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#CompositeGenericTransform-transform_path_affine">transform_path_affine</a>(<a href="#CompositeGenericTransform-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<hr>
Data descriptors defined here:<br>
<dl><dt><strong>is_affine</strong></dt>
</dl>
<dl><dt><strong>is_separable</strong></dt>
</dl>
<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>pass_through</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="CompositeGenericTransform-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt><dd><tt>Used by C/C++ -based backends to get at the array matrix data.</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<dl><dt><strong>input_dims</strong> = None</dl>
<dl><dt><strong>output_dims</strong> = None</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="CompositeGenericTransform-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="CompositeGenericTransform-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="CompositeGenericTransform-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="CompositeGenericTransform-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="IdentityTransform">class <strong>IdentityTransform</strong></a>(<a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>A special class that does on thing, the identity transform, in a<br>
fast way.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#IdentityTransform">IdentityTransform</a></dd>
<dd><a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a></dd>
<dd><a href="matplotlib.transforms.html#AffineBase">AffineBase</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="IdentityTransform-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="IdentityTransform-__str__"><strong>__str__</strong></a> = <a href="#IdentityTransform-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="IdentityTransform-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="IdentityTransform-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#IdentityTransform-inverted">inverted</a>().<a href="#IdentityTransform-transform">transform</a>(<a href="#IdentityTransform-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="IdentityTransform-get_matrix"><strong>get_matrix</strong></a>(self)</dt><dd><tt>Get the underlying transformation matrix as a numpy array.</tt></dd></dl>
<dl><dt><a name="IdentityTransform-inverted"><strong>inverted</strong></a> = <a href="#IdentityTransform-get_affine">get_affine</a>(self)</dt></dl>
<dl><dt><a name="IdentityTransform-transform"><strong>transform</strong></a>(self, points)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#IdentityTransform-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#IdentityTransform-transform_affine">transform_affine</a>(<a href="#IdentityTransform-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#IdentityTransform-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="IdentityTransform-transform_affine"><strong>transform_affine</strong></a> = <a href="#IdentityTransform-transform">transform</a>(self, points)</dt></dl>
<dl><dt><a name="IdentityTransform-transform_non_affine"><strong>transform_non_affine</strong></a> = <a href="#IdentityTransform-transform">transform</a>(self, points)</dt></dl>
<dl><dt><a name="IdentityTransform-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#IdentityTransform-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#IdentityTransform-transform_path_affine">transform_path_affine</a>(<a href="#IdentityTransform-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="IdentityTransform-transform_path_affine"><strong>transform_path_affine</strong></a> = <a href="#IdentityTransform-transform_path">transform_path</a>(self, path)</dt></dl>
<dl><dt><a name="IdentityTransform-transform_path_non_affine"><strong>transform_path_non_affine</strong></a> = <a href="#IdentityTransform-transform_path">transform_path</a>(self, path)</dt></dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="IdentityTransform-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="IdentityTransform-to_values"><strong>to_values</strong></a>(self)</dt><dd><tt>Return the values of the matrix as a sequence (a,b,c,d,e,f)</tt></dd></dl>
<dl><dt><a name="IdentityTransform-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Static methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="IdentityTransform-matrix_from_values"><strong>matrix_from_values</strong></a>(a, b, c, d, e, f)</dt><dd><tt>(staticmethod) Create a new transformation matrix as a 3x3<br>
numpy array of the form::<br>
<br>
a c e<br>
b d f<br>
0 0 1</tt></dd></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><strong>is_separable</strong></dt>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><strong>input_dims</strong> = 2</dl>
<dl><dt><strong>output_dims</strong> = 2</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><a name="IdentityTransform-__init__"><strong>__init__</strong></a>(self)</dt></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><strong>is_affine</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="IdentityTransform-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="IdentityTransform-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="IdentityTransform-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="IdentityTransform-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="IdentityTransform-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="IdentityTransform-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="IdentityTransform-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="ScaledTranslation">class <strong>ScaledTranslation</strong></a>(<a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>A transformation that translates by xt and yt, after xt and yt<br>
have been transformaed by the given transform scale_trans.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#ScaledTranslation">ScaledTranslation</a></dd>
<dd><a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a></dd>
<dd><a href="matplotlib.transforms.html#AffineBase">AffineBase</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="ScaledTranslation-__init__"><strong>__init__</strong></a>(self, xt, yt, scale_trans)</dt></dl>
<dl><dt><a name="ScaledTranslation-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="ScaledTranslation-__str__"><strong>__str__</strong></a> = <a href="#ScaledTranslation-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="ScaledTranslation-get_matrix"><strong>get_matrix</strong></a>(self)</dt><dd><tt>Get the underlying transformation matrix as a numpy array.</tt></dd></dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="ScaledTranslation-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="ScaledTranslation-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#ScaledTranslation-inverted">inverted</a>().<a href="#ScaledTranslation-transform">transform</a>(<a href="#ScaledTranslation-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-to_values"><strong>to_values</strong></a>(self)</dt><dd><tt>Return the values of the matrix as a sequence (a,b,c,d,e,f)</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-transform"><strong>transform</strong></a>(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#ScaledTranslation-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#ScaledTranslation-transform_affine">transform_affine</a>(<a href="#ScaledTranslation-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#ScaledTranslation-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-transform_affine"><strong>transform_affine</strong></a> = transform(self, points)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#ScaledTranslation-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#ScaledTranslation-transform_affine">transform_affine</a>(<a href="#ScaledTranslation-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#ScaledTranslation-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Static methods inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><a name="ScaledTranslation-matrix_from_values"><strong>matrix_from_values</strong></a>(a, b, c, d, e, f)</dt><dd><tt>(staticmethod) Create a new transformation matrix as a 3x3<br>
numpy array of the form::<br>
<br>
a c e<br>
b d f<br>
0 0 1</tt></dd></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><strong>is_separable</strong></dt>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Affine2DBase">Affine2DBase</a>:<br>
<dl><dt><strong>input_dims</strong> = 2</dl>
<dl><dt><strong>output_dims</strong> = 2</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><a name="ScaledTranslation-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-transform_non_affine"><strong>transform_non_affine</strong></a>(self, points)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#ScaledTranslation-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#ScaledTranslation-transform_affine">transform_affine</a>(<a href="#ScaledTranslation-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#ScaledTranslation-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#ScaledTranslation-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#ScaledTranslation-transform_path_affine">transform_path_affine</a>(<a href="#ScaledTranslation-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#ScaledTranslation-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#ScaledTranslation-transform_path_affine">transform_path_affine</a>(<a href="#ScaledTranslation-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#AffineBase">AffineBase</a>:<br>
<dl><dt><strong>is_affine</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="ScaledTranslation-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="ScaledTranslation-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="ScaledTranslation-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="ScaledTranslation-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="Transform">class <strong>Transform</strong></a>(<a href="matplotlib.transforms.html#TransformNode">TransformNode</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>The base class of all TransformNodes that actually perform a<br>
transformation.<br>
<br>
All non-affine transformations should be subclasses of this class.<br>
New affine transformations should be subclasses of<br>
:class:`<a href="#Affine2D">Affine2D</a>`.<br>
<br>
Subclasses of this class should override the following members (at<br>
minimum):<br>
<br>
- :attr:`input_dims`<br>
- :attr:`output_dims`<br>
- :meth:`transform`<br>
- :attr:`is_separable`<br>
- :attr:`has_inverse`<br>
- :meth:`inverted` (if :meth:`has_inverse` can return True)<br>
<br>
If the transform needs to do something non-standard with<br>
:class:`mathplotlib.path.Path` objects, such as adding curves<br>
where there were once line segments, it should override:<br>
<br>
- :meth:`transform_path`<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="Transform-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="Transform-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt><dd><tt>Used by C/C++ -based backends to get at the array matrix data.</tt></dd></dl>
<dl><dt><a name="Transform-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="Transform-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="Transform-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#Transform-inverted">inverted</a>().<a href="#Transform-transform">transform</a>(<a href="#Transform-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="Transform-transform"><strong>transform</strong></a>(self, values)</dt><dd><tt>Performs the transformation on the given array of values.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="Transform-transform_affine"><strong>transform_affine</strong></a>(self, values)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#Transform-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#Transform-transform_affine">transform_affine</a>(<a href="#Transform-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#Transform-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="Transform-transform_non_affine"><strong>transform_non_affine</strong></a>(self, values)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#Transform-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#Transform-transform_affine">transform_affine</a>(<a href="#Transform-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#Transform-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="Transform-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<dl><dt><a name="Transform-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#Transform-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#Transform-transform_path_affine">transform_path_affine</a>(<a href="#Transform-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="Transform-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#Transform-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#Transform-transform_path_affine">transform_path_affine</a>(<a href="#Transform-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="Transform-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>has_inverse</strong> = False</dl>
<dl><dt><strong>input_dims</strong> = None</dl>
<dl><dt><strong>is_separable</strong> = False</dl>
<dl><dt><strong>output_dims</strong> = None</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="Transform-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="Transform-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="Transform-__init__"><strong>__init__</strong></a>(self)</dt><dd><tt>Creates a new <a href="#TransformNode">TransformNode</a>.</tt></dd></dl>
<dl><dt><a name="Transform-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="Transform-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="Transform-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="Transform-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_affine</strong> = False</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="TransformNode">class <strong>TransformNode</strong></a>(<a href="__builtin__.html#object">__builtin__.object</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>:class:`<a href="#TransformNode">TransformNode</a>` is the base class for anything that<br>
participates in the transform tree and needs to invalidate its<br>
parents or be invalidated. This includes classes that are not<br>
really transforms, such as bounding boxes, since some transforms<br>
depend on bounding boxes to compute their values.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%">Methods defined here:<br>
<dl><dt><a name="TransformNode-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="TransformNode-__deepcopy__"><strong>__deepcopy__</strong></a> = <a href="#TransformNode-__copy__">__copy__</a>(self, *args)</dt></dl>
<dl><dt><a name="TransformNode-__init__"><strong>__init__</strong></a>(self)</dt><dd><tt>Creates a new <a href="#TransformNode">TransformNode</a>.</tt></dd></dl>
<dl><dt><a name="TransformNode-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="TransformNode-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="TransformNode-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="TransformNode-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors defined here:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_affine</strong> = False</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="TransformWrapper">class <strong>TransformWrapper</strong></a>(<a href="matplotlib.transforms.html#Transform">Transform</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>A helper class that holds a single child transform and acts<br>
equivalently to it.<br>
<br>
This is useful if a node of the transform tree must be replaced at<br>
run time with a transform of a different type. This class allows<br>
that replacement to correctly trigger invalidation.<br>
<br>
Note that :class:`<a href="#TransformWrapper">TransformWrapper</a>` instances must have the same<br>
input and output dimensions during their entire lifetime, so the<br>
child transform may only be replaced with another child transform<br>
of the same dimensions.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#TransformWrapper">TransformWrapper</a></dd>
<dd><a href="matplotlib.transforms.html#Transform">Transform</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="TransformWrapper-__init__"><strong>__init__</strong></a>(self, child)</dt><dd><tt>child: A <a href="#Transform">Transform</a> instance. This child may later be replaced<br>
with :meth:`set`.</tt></dd></dl>
<dl><dt><a name="TransformWrapper-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="TransformWrapper-__str__"><strong>__str__</strong></a> = <a href="#TransformWrapper-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="TransformWrapper-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="TransformWrapper-set"><strong>set</strong></a>(self, child)</dt><dd><tt>Replace the current child of this transform with another one.<br>
<br>
The new child must have the same number of input and output<br>
dimensions as the current child.</tt></dd></dl>
<hr>
Data descriptors defined here:<br>
<dl><dt><strong>has_inverse</strong></dt>
</dl>
<dl><dt><strong>is_affine</strong></dt>
</dl>
<dl><dt><strong>is_separable</strong></dt>
</dl>
<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>pass_through</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><a name="TransformWrapper-__add__"><strong>__add__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="TransformWrapper-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt><dd><tt>Used by C/C++ -based backends to get at the array matrix data.</tt></dd></dl>
<dl><dt><a name="TransformWrapper-__radd__"><strong>__radd__</strong></a>(self, other)</dt><dd><tt>Composes two transforms together such that self is followed by other.</tt></dd></dl>
<dl><dt><a name="TransformWrapper-get_affine"><strong>get_affine</strong></a>(self)</dt><dd><tt>Get the affine part of this transform.</tt></dd></dl>
<dl><dt><a name="TransformWrapper-inverted"><strong>inverted</strong></a>(self)</dt><dd><tt>Return the corresponding inverse transformation.<br>
<br>
The return value of this method should be treated as<br>
temporary. An update to 'self' does not cause a corresponding<br>
update to its inverted copy.<br>
<br>
``x === <a href="#TransformWrapper-inverted">inverted</a>().<a href="#TransformWrapper-transform">transform</a>(<a href="#TransformWrapper-transform">transform</a>(x))``</tt></dd></dl>
<dl><dt><a name="TransformWrapper-transform"><strong>transform</strong></a>(self, values)</dt><dd><tt>Performs the transformation on the given array of values.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="TransformWrapper-transform_affine"><strong>transform_affine</strong></a>(self, values)</dt><dd><tt>Performs only the affine part of this transformation on the<br>
given array of values.<br>
<br>
``<a href="#TransformWrapper-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#TransformWrapper-transform_affine">transform_affine</a>(<a href="#TransformWrapper-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally a no-op. In<br>
affine transformations, this is equivalent to<br>
``<a href="#TransformWrapper-transform">transform</a>(values)``.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="TransformWrapper-transform_non_affine"><strong>transform_non_affine</strong></a>(self, values)</dt><dd><tt>Performs only the non-affine part of the transformation.<br>
<br>
``<a href="#TransformWrapper-transform">transform</a>(values)`` is always equivalent to<br>
``<a href="#TransformWrapper-transform_affine">transform_affine</a>(<a href="#TransformWrapper-transform_non_affine">transform_non_affine</a>(values))``.<br>
<br>
In non-affine transformations, this is generally equivalent to<br>
``<a href="#TransformWrapper-transform">transform</a>(values)``. In affine transformations, this is<br>
always a no-op.<br>
<br>
Accepts a numpy array of shape (N x :attr:`input_dims`) and<br>
returns a numpy array of shape (N x :attr:`output_dims`).</tt></dd></dl>
<dl><dt><a name="TransformWrapper-transform_path"><strong>transform_path</strong></a>(self, path)</dt><dd><tt>Returns a transformed copy of path.<br>
<br>
path: a Path instance.<br>
<br>
In some cases, this transform may insert curves into the path<br>
that began as line segments.</tt></dd></dl>
<dl><dt><a name="TransformWrapper-transform_path_affine"><strong>transform_path_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the affine part of<br>
this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#TransformWrapper-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#TransformWrapper-transform_path_affine">transform_path_affine</a>(<a href="#TransformWrapper-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="TransformWrapper-transform_path_non_affine"><strong>transform_path_non_affine</strong></a>(self, path)</dt><dd><tt>Returns a copy of path, transformed only by the non-affine<br>
part of this transform.<br>
<br>
path: a Path instance<br>
<br>
``<a href="#TransformWrapper-transform_path">transform_path</a>(path)`` is equivalent to<br>
``<a href="#TransformWrapper-transform_path_affine">transform_path_affine</a>(<a href="#TransformWrapper-transform_path_non_affine">transform_path_non_affine</a>(values))``.</tt></dd></dl>
<dl><dt><a name="TransformWrapper-transform_point"><strong>transform_point</strong></a>(self, point)</dt><dd><tt>A convenience function that returns the transformed copy of a<br>
single point.<br>
<br>
The point is given as a sequence of length :attr:`input_dims`.<br>
The transformed point is returned as a sequence of length<br>
:attr:`output_dims`.</tt></dd></dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#Transform">Transform</a>:<br>
<dl><dt><strong>input_dims</strong> = None</dl>
<dl><dt><strong>output_dims</strong> = None</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="TransformWrapper-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="TransformWrapper-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="TransformWrapper-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="TransformWrapper-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="TransformWrapper-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="TransformedBbox">class <strong>TransformedBbox</strong></a>(<a href="matplotlib.transforms.html#BboxBase">BboxBase</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>A :class:`<a href="#Bbox">Bbox</a>` that is automatically transformed by a given<br>
transform. When either the child bounding box or transform<br>
changes, the bounds of this bbox will update accordingly.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#TransformedBbox">TransformedBbox</a></dd>
<dd><a href="matplotlib.transforms.html#BboxBase">BboxBase</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="TransformedBbox-__init__"><strong>__init__</strong></a>(self, bbox, transform)</dt><dd><tt>bbox: a child bbox<br>
<br>
transform: a 2D transform</tt></dd></dl>
<dl><dt><a name="TransformedBbox-__repr__"><strong>__repr__</strong></a>(self)</dt></dl>
<dl><dt><a name="TransformedBbox-__str__"><strong>__str__</strong></a> = <a href="#TransformedBbox-__repr__">__repr__</a>(self)</dt></dl>
<dl><dt><a name="TransformedBbox-get_points"><strong>get_points</strong></a>(self)</dt><dd><tt>Get the points of the bounding box directly as a numpy array<br>
of the form: [[x0, y0], [x1, y1]].</tt></dd></dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#BboxBase">BboxBase</a>:<br>
<dl><dt><a name="TransformedBbox-__array__"><strong>__array__</strong></a>(self, *args, **kwargs)</dt></dl>
<dl><dt><a name="TransformedBbox-anchored"><strong>anchored</strong></a>(self, c, container<font color="#909090">=None</font>)</dt><dd><tt>Return a copy of the <a href="#Bbox">Bbox</a>, shifted to position c within a<br>
container.<br>
<br>
c: may be either:<br>
<br>
* a sequence (cx, cy) where cx, cy range<br>
from 0 to 1, where 0 is left or bottom and 1 is right or top<br>
<br>
* a string:<br>
- C for centered<br>
- S for bottom-center<br>
- SE for bottom-left<br>
- E for left<br>
- etc.<br>
<br>
Optional argument *container* is the box within which the :class:`<a href="#Bbox">Bbox</a>`<br>
is positioned; it defaults to the initial :class:`<a href="#Bbox">Bbox</a>`.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-contains"><strong>contains</strong></a>(self, x, y)</dt><dd><tt>Returns True if (x, y) is a coordinate inside the bounding<br>
box or on its edge.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-containsx"><strong>containsx</strong></a>(self, x)</dt><dd><tt>Returns True if x is between or equal to :attr:`x0` and<br>
:attr:`x1`.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-containsy"><strong>containsy</strong></a>(self, y)</dt><dd><tt>Returns True if y is between or equal to :attr:`y0` and<br>
:attr:`y1`.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-corners"><strong>corners</strong></a>(self)</dt><dd><tt>Return an array of points which are the four corners of this<br>
rectangle. For example, if this :class:`<a href="#Bbox">Bbox</a>` is defined by<br>
the points (*a*, *b*) and (*c*, *d*), :meth:`corners` returns<br>
(*a*, *b*), (*a*, *d*), (*c*, *b*) and (*c*, *d*).</tt></dd></dl>
<dl><dt><a name="TransformedBbox-count_contains"><strong>count_contains</strong></a>(self, vertices)</dt><dd><tt>Count the number of vertices contained in the <a href="#Bbox">Bbox</a>.<br>
<br>
vertices is a Nx2 numpy array.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-count_overlaps"><strong>count_overlaps</strong></a>(self, bboxes)</dt><dd><tt>Count the number of bounding boxes that overlap this one.<br>
<br>
bboxes is a sequence of :class:`<a href="#BboxBase">BboxBase</a>` objects</tt></dd></dl>
<dl><dt><a name="TransformedBbox-expanded"><strong>expanded</strong></a>(self, sw, sh)</dt><dd><tt>Return a new :class:`<a href="#Bbox">Bbox</a>` which is this :class:`<a href="#Bbox">Bbox</a>`<br>
expanded around its center by the given factors *sw* and<br>
*sh*.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>:class:`<a href="#TransformNode">TransformNode</a>` is the base class for anything that<br>
participates in the transform tree and needs to invalidate its<br>
parents or be invalidated. This includes classes that are not<br>
really transforms, such as bounding boxes, since some transforms<br>
depend on bounding boxes to compute their values.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-fully_contains"><strong>fully_contains</strong></a>(self, x, y)</dt><dd><tt>Returns True if (x, y) is a coordinate inside the bounding<br>
box, but not on its edge.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-fully_containsx"><strong>fully_containsx</strong></a>(self, x)</dt><dd><tt>Returns True if x is between but not equal to :attr:`x0` and<br>
:attr:`x1`.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-fully_containsy"><strong>fully_containsy</strong></a>(self, y)</dt><dd><tt>Returns True if y is between but not equal to :attr:`y0` and<br>
:attr:`y1`.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-fully_overlaps"><strong>fully_overlaps</strong></a>(self, other)</dt><dd><tt>Returns True if this bounding box overlaps with the given<br>
bounding box *other*, but not on its edge alone.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-inverse_transformed"><strong>inverse_transformed</strong></a>(self, transform)</dt><dd><tt>Return a new :class:`<a href="#Bbox">Bbox</a>` <a href="__builtin__.html#object">object</a>, statically transformed by<br>
the inverse of the given transform.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-is_unit"><strong>is_unit</strong></a>(self)</dt><dd><tt>Returns True if the <a href="#Bbox">Bbox</a> is the unit bounding box from (0, 0)<br>
to (1, 1).</tt></dd></dl>
<dl><dt><a name="TransformedBbox-overlaps"><strong>overlaps</strong></a>(self, other)</dt><dd><tt>Returns True if this bounding box overlaps with the given<br>
bounding box *other*.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-padded"><strong>padded</strong></a>(self, p)</dt><dd><tt>Return a new :class:`<a href="#Bbox">Bbox</a>` that is padded on all four sides by<br>
the given value.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-rotated"><strong>rotated</strong></a>(self, radians)</dt><dd><tt>Return a new bounding box that bounds a rotated version of<br>
this bounding box by the given radians. The new bounding box<br>
is still aligned with the axes, of course.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-shrunk"><strong>shrunk</strong></a>(self, mx, my)</dt><dd><tt>Return a copy of the :class:`<a href="#Bbox">Bbox</a>`, shurnk by the factor mx in<br>
the *x* direction and the factor my in the *y* direction. The<br>
lower left corner of the box remains unchanged. Normally mx<br>
and my will be less than 1, but this is not enforced.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-shrunk_to_aspect"><strong>shrunk_to_aspect</strong></a>(self, box_aspect, container<font color="#909090">=None</font>, fig_aspect<font color="#909090">=1.0</font>)</dt><dd><tt>Return a copy of the :class:`<a href="#Bbox">Bbox</a>`, shrunk so that it is as<br>
large as it can be while having the desired aspect ratio,<br>
*box_aspect*. If the box coordinates are relative---that<br>
is, fractions of a larger box such as a figure---then the<br>
physical aspect ratio of that figure is specified with<br>
*fig_aspect*, so that *box_aspect* can also be given as a<br>
ratio of the absolute dimensions, not the relative dimensions.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-splitx"><strong>splitx</strong></a>(self, *args)</dt><dd><tt>e.g., ``bbox.<a href="#TransformedBbox-splitx">splitx</a>(f1, f2, ...)``<br>
<br>
Returns a list of new :class:`<a href="#Bbox">Bbox</a>` objects formed by<br>
splitting the original one with vertical lines at fractional<br>
positions *f1*, *f2*, ...</tt></dd></dl>
<dl><dt><a name="TransformedBbox-splity"><strong>splity</strong></a>(self, *args)</dt><dd><tt>e.g., ``bbox.<a href="#TransformedBbox-splitx">splitx</a>(f1, f2, ...)``<br>
<br>
Returns a list of new :class:`<a href="#Bbox">Bbox</a>` objects formed by<br>
splitting the original one with horizontal lines at fractional<br>
positions *f1*, *f2*, ...</tt></dd></dl>
<dl><dt><a name="TransformedBbox-transformed"><strong>transformed</strong></a>(self, transform)</dt><dd><tt>Return a new :class:`<a href="#Bbox">Bbox</a>` <a href="__builtin__.html#object">object</a>, statically transformed by<br>
the given transform.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-translated"><strong>translated</strong></a>(self, tx, ty)</dt><dd><tt>Return a copy of the :class:`<a href="#Bbox">Bbox</a>`, statically translated by<br>
tx and ty.</tt></dd></dl>
<hr>
Static methods inherited from <a href="matplotlib.transforms.html#BboxBase">BboxBase</a>:<br>
<dl><dt><a name="TransformedBbox-union"><strong>union</strong></a>(bboxes)</dt><dd><tt>Return a :class:`<a href="#Bbox">Bbox</a>` that contains all of the given bboxes.</tt></dd></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#BboxBase">BboxBase</a>:<br>
<dl><dt><strong>bounds</strong></dt>
<dd><tt>(property) Returns (:attr:`x0`, :attr:`y0`, :attr:`width`, :attr:`height`).</tt></dd>
</dl>
<dl><dt><strong>extents</strong></dt>
<dd><tt>(property) Returns (:attr:`x0`, :attr:`y0`, :attr:`x1`, :attr:`y1`).</tt></dd>
</dl>
<dl><dt><strong>height</strong></dt>
<dd><tt>(property) The height of the bounding box. It may be negative if :attr:`y1` <<br>
:attr:`y0`.</tt></dd>
</dl>
<dl><dt><strong>intervalx</strong></dt>
<dd><tt>(property) :attr:`intervalx` is the pair of *x* coordinates that define the<br>
bounding box. It is not guaranteed to be sorted from left to right.</tt></dd>
</dl>
<dl><dt><strong>intervaly</strong></dt>
<dd><tt>(property) :attr:`intervaly` is the pair of *y* coordinates that define the<br>
bounding box. It is not guaranteed to be sorted from bottom to top.</tt></dd>
</dl>
<dl><dt><strong>max</strong></dt>
<dd><tt>(property) :attr:`max` is the top-right corner of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>min</strong></dt>
<dd><tt>(property) :attr:`min` is the bottom-left corner of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>p0</strong></dt>
<dd><tt>(property) :attr:`p0` is the first pair of (*x*, *y*) coordinates that<br>
define the bounding box. It is not guaranteed to be the bottom-left<br>
corner. For that, use :attr:`min`.</tt></dd>
</dl>
<dl><dt><strong>p1</strong></dt>
<dd><tt>(property) :attr:`p1` is the second pair of (*x*, *y*) coordinates that<br>
define the bounding box. It is not guaranteed to be the top-right<br>
corner. For that, use :attr:`max`.</tt></dd>
</dl>
<dl><dt><strong>size</strong></dt>
<dd><tt>(property) The width and height of the bounding box. May be negative, in the same<br>
way as :attr:`width` and :attr:`height`.</tt></dd>
</dl>
<dl><dt><strong>width</strong></dt>
<dd><tt>(property) The width of the bounding box. It may be negative if :attr:`x1` <<br>
:attr:`x0`.</tt></dd>
</dl>
<dl><dt><strong>x0</strong></dt>
<dd><tt>(property) :attr:`x0` is the first of the pair of *x* coordinates that<br>
define the bounding box. :attr:`x0` is not guaranteed to be<br>
less than :attr:`x1`. If you require that, use :attr:`xmin`.</tt></dd>
</dl>
<dl><dt><strong>x1</strong></dt>
<dd><tt>(property) :attr:`x1` is the second of the pair of *x* coordinates that<br>
define the bounding box. :attr:`x1` is not guaranteed to be<br>
greater than :attr:`x0`. If you require that, use :attr:`xmax`.</tt></dd>
</dl>
<dl><dt><strong>xmax</strong></dt>
<dd><tt>(property) :attr:`xmax` is the right edge of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>xmin</strong></dt>
<dd><tt>(property) :attr:`xmin` is the left edge of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>y0</strong></dt>
<dd><tt>(property) :attr:`y0` is the first of the pair of *y* coordinates that<br>
define the bounding box. :attr:`y0` is not guaranteed to be<br>
less than :attr:`y1`. If you require that, use :attr:`ymin`.</tt></dd>
</dl>
<dl><dt><strong>y1</strong></dt>
<dd><tt>(property) :attr:`y1` is the second of the pair of *y* coordinates that<br>
define the bounding box. :attr:`y1` is not guaranteed to be<br>
greater than :attr:`y0`. If you require that, use :attr:`ymax`.</tt></dd>
</dl>
<dl><dt><strong>ymax</strong></dt>
<dd><tt>(property) :attr:`ymax` is the top edge of the bounding box.</tt></dd>
</dl>
<dl><dt><strong>ymin</strong></dt>
<dd><tt>(property) :attr:`ymin` is the bottom edge of the bounding box.</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#BboxBase">BboxBase</a>:<br>
<dl><dt><strong>coefs</strong> = {'C': (0.5, 0.5), 'E': (1.0, 0.5), 'N': (0.5, 1.0), 'NE': (1.0, 1.0), 'NW': (0, 1.0), 'S': (0.5, 0), 'SE': (1.0, 0), 'SW': (0, 0), 'W': (0, 0.5)}</dl>
<dl><dt><strong>is_affine</strong> = True</dl>
<dl><dt><strong>is_bbox</strong> = True</dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="TransformedBbox-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="TransformedBbox-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="TransformedBbox-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table> <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom> <br>
<font color="#000000" face="helvetica, arial"><a name="TransformedPath">class <strong>TransformedPath</strong></a>(<a href="matplotlib.transforms.html#TransformNode">TransformNode</a>)</font></td></tr>
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
<td colspan=2><tt>A <a href="#TransformedPath">TransformedPath</a> caches a non-affine transformed copy of the<br>
path. This cached copy is automatically updated when the<br>
non-affine part of the transform changes.<br> </tt></td></tr>
<tr><td> </td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="matplotlib.transforms.html#TransformedPath">TransformedPath</a></dd>
<dd><a href="matplotlib.transforms.html#TransformNode">TransformNode</a></dd>
<dd><a href="__builtin__.html#object">__builtin__.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="TransformedPath-__init__"><strong>__init__</strong></a>(self, path, transform)</dt><dd><tt>Create a new <a href="#TransformedPath">TransformedPath</a> from the given path and transform.</tt></dd></dl>
<dl><dt><a name="TransformedPath-get_affine"><strong>get_affine</strong></a>(self)</dt></dl>
<dl><dt><a name="TransformedPath-get_fully_transformed_path"><strong>get_fully_transformed_path</strong></a>(self)</dt><dd><tt>Return a fully-transformed copy of the child path.</tt></dd></dl>
<dl><dt><a name="TransformedPath-get_transformed_path_and_affine"><strong>get_transformed_path_and_affine</strong></a>(self)</dt><dd><tt>Return a copy of the child path, with the non-affine part of<br>
the transform already applied, along with the affine part of<br>
the path necessary to complete the transformation.</tt></dd></dl>
<dl><dt><a name="TransformedPath-get_transformed_points_and_affine"><strong>get_transformed_points_and_affine</strong></a>(self)</dt><dd><tt>Return a copy of the child path, with the non-affine part of<br>
the transform already applied, along with the affine part of<br>
the path necessary to complete the transformation. Unlike<br>
get_transformed_path_and_affine, no interpolation will be<br>
performed.</tt></dd></dl>
<hr>
Methods inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><a name="TransformedPath-__copy__"><strong>__copy__</strong></a>(self, *args)</dt></dl>
<dl><dt><a name="TransformedPath-__deepcopy__"><strong>__deepcopy__</strong></a> = __copy__(self, *args)</dt></dl>
<dl><dt><a name="TransformedPath-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt>Returns a frozen copy of this transform node. The frozen copy<br>
will not update when its children change. Useful for storing<br>
a previously known state of a transform where copy.deepcopy()<br>
might normally be used.</tt></dd></dl>
<dl><dt><a name="TransformedPath-invalidate"><strong>invalidate</strong></a>(self)</dt><dd><tt>Invalidate this transform node and all of its ancestors.<br>
Should be called any time the transform changes.</tt></dd></dl>
<dl><dt><a name="TransformedPath-set_children"><strong>set_children</strong></a>(self, *children)</dt><dd><tt>Set the children of the transform, to let the invalidation<br>
system know which transforms can invalidate this transform.<br>
Should be called from the constructor of any transforms that<br>
depend on other transforms.</tt></dd></dl>
<dl><dt><a name="TransformedPath-write_graphviz"><strong>write_graphviz</strong></a>(self, fobj, highlight<font color="#909090">=[]</font>)</dt></dl>
<hr>
Data descriptors inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list of weak references to the object (if defined)</tt></dd>
</dl>
<hr>
Data and other attributes inherited from <a href="matplotlib.transforms.html#TransformNode">TransformNode</a>:<br>
<dl><dt><strong>INVALID</strong> = 3</dl>
<dl><dt><strong>INVALID_AFFINE</strong> = 2</dl>
<dl><dt><strong>INVALID_NON_AFFINE</strong> = 1</dl>
<dl><dt><strong>is_affine</strong> = False</dl>
<dl><dt><strong>is_bbox</strong> = False</dl>
<dl><dt><strong>pass_through</strong> = False</dl>
</td></tr></table></td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#eeaa77">
<td colspan=3 valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Functions</strong></big></font></td></tr>
<tr><td bgcolor="#eeaa77"><tt> </tt></td><td> </td>
<td width="100%"><dl><dt><a name="-affine_transform"><strong>affine_transform</strong></a>(...)</dt><dd><tt><a href="#-affine_transform">affine_transform</a>(vertices, transform)</tt></dd></dl>
<dl><dt><a name="-blended_transform_factory"><strong>blended_transform_factory</strong></a>(x_transform, y_transform)</dt><dd><tt>Create a new "blended" transform using x_transform to<br>
transform the x-axis and y_transform to transform the y_axis.<br>
<br>
A faster version of the blended transform is returned for the case<br>
where both child transforms are affine.</tt></dd></dl>
<dl><dt><a name="-composite_transform_factory"><strong>composite_transform_factory</strong></a>(a, b)</dt><dd><tt>Create a new composite transform that is the result of applying<br>
transform a then transform b.<br>
<br>
Shortcut versions of the blended transform are provided for the<br>
case where both child transforms are affine, or one or the other<br>
is the identity transform.<br>
<br>
Composite transforms may also be created using the '+' operator,<br>
e.g.:<br>
<br>
c = a + b</tt></dd></dl>
<dl><dt><a name="-count_bboxes_overlapping_bbox"><strong>count_bboxes_overlapping_bbox</strong></a>(...)</dt><dd><tt><a href="#-count_bboxes_overlapping_bbox">count_bboxes_overlapping_bbox</a>(bbox, bboxes)</tt></dd></dl>
<dl><dt><a name="-interval_contains"><strong>interval_contains</strong></a>(interval, val)</dt></dl>
<dl><dt><a name="-interval_contains_open"><strong>interval_contains_open</strong></a>(interval, val)</dt></dl>
<dl><dt><a name="-nonsingular"><strong>nonsingular</strong></a>(vmin, vmax, expander<font color="#909090">=0.001</font>, tiny<font color="#909090">=1.0000000000000001e-15</font>, increasing<font color="#909090">=True</font>)</dt><dd><tt>Ensure the endpoints of a range are not too close together.<br>
<br>
"too close" means the interval is smaller than 'tiny' times<br>
the maximum absolute value.<br>
<br>
If they are too close, each will be moved by the 'expander'.<br>
If 'increasing' is True and vmin > vmax, they will be swapped,<br>
regardless of whether they are too close.</tt></dd></dl>
<dl><dt><a name="-offset_copy"><strong>offset_copy</strong></a>(trans, fig, x<font color="#909090">=0.0</font>, y<font color="#909090">=0.0</font>, units<font color="#909090">='inches'</font>)</dt><dd><tt>Return a new transform with an added offset.<br>
args:<br>
trans is any transform<br>
kwargs:<br>
fig is the current figure; it can be None if units are 'dots'<br>
x, y give the offset<br>
units is 'inches', 'points' or 'dots'</tt></dd></dl>
<dl><dt><a name="-update_path_extents"><strong>update_path_extents</strong></a>(...)</dt><dd><tt><a href="#-update_path_extents">update_path_extents</a>(path, trans, bbox, minpos)</tt></dd></dl>
</td></tr></table><p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#55aa55">
<td colspan=3 valign=bottom> <br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Data</strong></big></font></td></tr>
<tr><td bgcolor="#55aa55"><tt> </tt></td><td> </td>
<td width="100%"><strong>DEBUG</strong> = False</td></tr></table>
@footer@
