Menu
▾
▴
[r5327]: / trunk / htdocs / matplotlib.transforms.html.template Maximize Restore History
3402 lines (2760 with data), 226.1 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>This module contains a framework for arbitrary transformations.<br>
<br>
Transforms are composed into a 'transform tree', made of transforms<br>
whose value depends on other transforms (their children). When the<br>
contents of children change, their parents are automatically updated<br>
to reflect those changes. To do this an "invalidation" method is<br>
used: when children change, all of their ancestors are marked as<br>
"invalid". When the value of a transform is accessed at a later time,<br>
its value is recomputed only if it is invalid, otherwise a cached<br>
value may be used. This prevents unnecessary recomputations of<br>
transforms, and contributes to better interactive performance.<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 + affine<br>
<br>
2007 Michael Droettboom</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>
</td><td width="25%" valign=top><a href="numpy.ma.html">numpy.ma</a><br>
</td><td width="25%" valign=top><a href="numpy.html">numpy</a><br>
</td><td width="25%" valign=top><a href="warnings.html">warnings</a><br>
</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><td bgcolor="#ffc8d8"><tt> </tt></td><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 <a href="#Affine2D-rotate">rotate</a>(), <a href="#Affine2D-rotate_deg">rotate_deg</a>(), <a href="#Affine2D-translate">translate</a>() and <a href="#Affine2D-scale">scale</a>().</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 <a href="#Affine2D-rotate">rotate</a>(), <a href="#Affine2D-rotate_deg">rotate_deg</a>(), <a href="#Affine2D-translate">translate</a>() and <a href="#Affine2D-scale">scale</a>().</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 <a href="#Affine2D-rotate">rotate</a>(), <a href="#Affine2D-rotate_deg">rotate_deg</a>(), <a href="#Affine2D-translate">translate</a>() and <a href="#Affine2D-scale">scale</a>().</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 <a href="#Affine2D-rotate">rotate</a>(), <a href="#Affine2D-rotate_deg">rotate_deg</a>(), <a href="#Affine2D-translate">translate</a>() and <a href="#Affine2D-scale">scale</a>().</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 <a href="#Affine2D-rotate">rotate</a>(), <a href="#Affine2D-rotate_deg">rotate_deg</a>(), <a href="#Affine2D-translate">translate</a>() and <a href="#Affine2D-scale">scale</a>().</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>
<a href="#Affine2DBase">Affine2DBase</a> instance.</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 <a href="#Affine2D-rotate">rotate</a>(), <a href="#Affine2D-rotate_deg">rotate_deg</a>(), <a href="#Affine2D-translate">translate</a>() and <a href="#Affine2D-scale">scale</a>().</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>Create a new <a href="#Affine2D">Affine2D</a> instance from the given 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>Return a new <a href="#Affine2D">Affine2D</a> instance that is the identity transform.<br>
<br>
Unless this transform will be mutated later on, consider using<br>
the faster <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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</tt></dd></dl>
<dl><dt><a name="Affine2D-transform_point"><strong>transform_point</strong></a>(self, point)</dt></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>Create a new transformation matrix as a 3x3 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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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>
Provides the read-only interface.<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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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>Create a new transformation matrix as a 3x3 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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 self.<strong>input_dims</strong>.<br>
The transformed point is returned as a sequence of length<br>
self.<strong>output_dims</strong>.</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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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><td bgcolor="#ffc8d8"><tt> </tt></td><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>Create a new bounding box.<br>
<br>
points: a 2x2 numpy array of the form [[x0, y0], [x1, y1]]<br>
<br>
If you need to create <a href="#Bbox">Bbox</a> from another form of data, consider the<br>
class methods unit, from_bounds and 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>Set 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 update_from_data or<br>
update_from_data_xy.<br>
<br>
value: When True, subsequent calls to update_from_data will<br>
ignore the existing bounds of the <a href="#Bbox">Bbox</a>.<br>
When False, subsequent calls to update_from_data will<br>
include the existing bounds of the <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 <a href="#Bbox">Bbox</a> based on the passed in data.<br>
<br>
x: a numpy array of x-values<br>
y: a numpy array of y-values<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 <a href="#Bbox">Bbox</a>.<a href="#Bbox-ignore">ignore</a>().</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 <a href="#Bbox">Bbox</a> based on the passed in data.<br>
<br>
xy: a numpy array of 2D points<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 <a href="#Bbox">Bbox</a>.<a href="#Bbox-ignore">ignore</a>().</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>Create a new <a href="#Bbox">Bbox</a> from x0, y0, width 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>Create a new <a href="#Bbox">Bbox</a> from left, bottom, right and top.<br>
<br>
The y-axis increases upwards.</tt></dd></dl>
<dl><dt><a name="Bbox-unit"><strong>unit</strong></a>()</dt><dd><tt>Create a new unit BBox from (0, 0) to (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 a) 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>
or b) a string: C for centered, S for bottom-center, SE for<br>
bottom-left, E for left, etc.<br>
<br>
Optional arg container is the box within which the BBox<br>
is positioned; it defaults to the initial BBox.</tt></dd></dl>
<dl><dt><a name="Bbox-contains"><strong>contains</strong></a>(self, x, y)</dt></dl>
<dl><dt><a name="Bbox-containsx"><strong>containsx</strong></a>(self, x)</dt></dl>
<dl><dt><a name="Bbox-containsy"><strong>containsy</strong></a>(self, y)</dt></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.</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 <a href="#Bbox">Bbox</a> objects</tt></dd></dl>
<dl><dt><a name="Bbox-expanded"><strong>expanded</strong></a>(self, sw, sh)</dt><dd><tt>Return a new <a href="#Bbox">Bbox</a> which is this <a href="#Bbox">Bbox</a> expanded around its<br>
center by the given factors sw and sh.</tt></dd></dl>
<dl><dt><a name="Bbox-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt><a href="#TransformNode">TransformNode</a> is the base class for anything that participates in<br>
the transform tree and needs to invalidate its parents or be<br>
invalidated. It can include classes that are not technically<br>
transforms, such as bounding boxes, since some transforms depend<br>
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></dl>
<dl><dt><a name="Bbox-fully_containsx"><strong>fully_containsx</strong></a>(self, x)</dt></dl>
<dl><dt><a name="Bbox-fully_containsy"><strong>fully_containsy</strong></a>(self, y)</dt></dl>
<dl><dt><a name="Bbox-fully_overlaps"><strong>fully_overlaps</strong></a>(self, other)</dt></dl>
<dl><dt><a name="Bbox-inverse_transformed"><strong>inverse_transformed</strong></a>(self, transform)</dt><dd><tt>Return a new <a href="#Bbox">Bbox</a> <a href="__builtin__.html#object">object</a>, transformed by the inverse of the<br>
given transform.</tt></dd></dl>
<dl><dt><a name="Bbox-is_unit"><strong>is_unit</strong></a>(self)</dt></dl>
<dl><dt><a name="Bbox-overlaps"><strong>overlaps</strong></a>(self, other)</dt></dl>
<dl><dt><a name="Bbox-padded"><strong>padded</strong></a>(self, p)</dt><dd><tt>Return a new <a href="#Bbox">Bbox</a> that is padded on all four sides by the<br>
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 this<br>
bounding box. The new bounding box is still aligned with the<br>
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 <a href="#Bbox">Bbox</a>, shurnk by the factor mx in the x<br>
direction and the factor my in the y direction. The lower<br>
left corner of the box remains unchanged. Normally mx and my<br>
will be <= 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 <a href="#Bbox">Bbox</a>, shrunk so that it is as large as it<br>
can be while having the desired aspect ratio, box_aspect. If<br>
the box coordinates are relative--that is, fractions of a<br>
larger box such as a figure--then the physical aspect ratio of<br>
that figure is specified with fig_aspect, so that box_aspect<br>
can also be given as a ratio of the absolute dimensions, not<br>
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 BBoxes formed by<br>
splitting the original one with vertical lines<br>
at fractional 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 PBoxes formed by<br>
splitting the original one with horizontal lines<br>
at fractional positions f1, f2, ...</tt></dd></dl>
<dl><dt><a name="Bbox-transformed"><strong>transformed</strong></a>(self, transform)</dt><dd><tt>Return a new <a href="#Bbox">Bbox</a> <a href="__builtin__.html#object">object</a>, transformed by 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 <a href="#Bbox">Bbox</a>, translated by 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 <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>
</dl>
<dl><dt><strong>height</strong></dt>
</dl>
<dl><dt><strong>max</strong></dt>
</dl>
<dl><dt><strong>min</strong></dt>
</dl>
<dl><dt><strong>size</strong></dt>
</dl>
<dl><dt><strong>width</strong></dt>
</dl>
<dl><dt><strong>xmax</strong></dt>
</dl>
<dl><dt><strong>xmin</strong></dt>
</dl>
<dl><dt><strong>ymax</strong></dt>
</dl>
<dl><dt><strong>ymin</strong></dt>
</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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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.<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 a) 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>
or b) a string: C for centered, S for bottom-center, SE for<br>
bottom-left, E for left, etc.<br>
<br>
Optional arg container is the box within which the BBox<br>
is positioned; it defaults to the initial BBox.</tt></dd></dl>
<dl><dt><a name="BboxBase-contains"><strong>contains</strong></a>(self, x, y)</dt></dl>
<dl><dt><a name="BboxBase-containsx"><strong>containsx</strong></a>(self, x)</dt></dl>
<dl><dt><a name="BboxBase-containsy"><strong>containsy</strong></a>(self, y)</dt></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.</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 <a href="#Bbox">Bbox</a> objects</tt></dd></dl>
<dl><dt><a name="BboxBase-expanded"><strong>expanded</strong></a>(self, sw, sh)</dt><dd><tt>Return a new <a href="#Bbox">Bbox</a> which is this <a href="#Bbox">Bbox</a> expanded around its<br>
center by the given factors sw and sh.</tt></dd></dl>
<dl><dt><a name="BboxBase-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt><a href="#TransformNode">TransformNode</a> is the base class for anything that participates in<br>
the transform tree and needs to invalidate its parents or be<br>
invalidated. It can include classes that are not technically<br>
transforms, such as bounding boxes, since some transforms depend<br>
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></dl>
<dl><dt><a name="BboxBase-fully_containsx"><strong>fully_containsx</strong></a>(self, x)</dt></dl>
<dl><dt><a name="BboxBase-fully_containsy"><strong>fully_containsy</strong></a>(self, y)</dt></dl>
<dl><dt><a name="BboxBase-fully_overlaps"><strong>fully_overlaps</strong></a>(self, other)</dt></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 <a href="#Bbox">Bbox</a> <a href="__builtin__.html#object">object</a>, transformed by the inverse of the<br>
given transform.</tt></dd></dl>
<dl><dt><a name="BboxBase-is_unit"><strong>is_unit</strong></a>(self)</dt></dl>
<dl><dt><a name="BboxBase-overlaps"><strong>overlaps</strong></a>(self, other)</dt></dl>
<dl><dt><a name="BboxBase-padded"><strong>padded</strong></a>(self, p)</dt><dd><tt>Return a new <a href="#Bbox">Bbox</a> that is padded on all four sides by the<br>
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 this<br>
bounding box. The new bounding box is still aligned with the<br>
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 <a href="#Bbox">Bbox</a>, shurnk by the factor mx in the x<br>
direction and the factor my in the y direction. The lower<br>
left corner of the box remains unchanged. Normally mx and my<br>
will be <= 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 <a href="#Bbox">Bbox</a>, shrunk so that it is as large as it<br>
can be while having the desired aspect ratio, box_aspect. If<br>
the box coordinates are relative--that is, fractions of a<br>
larger box such as a figure--then the physical aspect ratio of<br>
that figure is specified with fig_aspect, so that box_aspect<br>
can also be given as a ratio of the absolute dimensions, not<br>
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 BBoxes formed by<br>
splitting the original one with vertical lines<br>
at fractional 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 PBoxes formed by<br>
splitting the original one with horizontal lines<br>
at fractional positions f1, f2, ...</tt></dd></dl>
<dl><dt><a name="BboxBase-transformed"><strong>transformed</strong></a>(self, transform)</dt><dd><tt>Return a new <a href="#Bbox">Bbox</a> <a href="__builtin__.html#object">object</a>, transformed by 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 <a href="#Bbox">Bbox</a>, translated by 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 <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>
</dl>
<dl><dt><strong>extents</strong></dt>
</dl>
<dl><dt><strong>height</strong></dt>
</dl>
<dl><dt><strong>intervalx</strong></dt>
</dl>
<dl><dt><strong>intervaly</strong></dt>
</dl>
<dl><dt><strong>max</strong></dt>
</dl>
<dl><dt><strong>min</strong></dt>
</dl>
<dl><dt><strong>p0</strong></dt>
</dl>
<dl><dt><strong>p1</strong></dt>
</dl>
<dl><dt><strong>size</strong></dt>
</dl>
<dl><dt><strong>width</strong></dt>
</dl>
<dl><dt><strong>x0</strong></dt>
</dl>
<dl><dt><strong>x1</strong></dt>
</dl>
<dl><dt><strong>xmax</strong></dt>
</dl>
<dl><dt><strong>xmin</strong></dt>
</dl>
<dl><dt><strong>y0</strong></dt>
</dl>
<dl><dt><strong>y1</strong></dt>
</dl>
<dl><dt><strong>ymax</strong></dt>
</dl>
<dl><dt><strong>ymin</strong></dt>
</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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</tt></dd></dl>
<dl><dt><a name="BboxTransform-transform_point"><strong>transform_point</strong></a>(self, point)</dt></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>Create a new transformation matrix as a 3x3 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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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 one <a href="#Bbox">Bbox</a> to the unit<br>
<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#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><dd><tt>Create a new <a href="#BboxTransform">BboxTransform</a> that linearly transforms points<br>
from boxin to the unit <a href="#Bbox">Bbox</a>.</tt></dd></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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</tt></dd></dl>
<dl><dt><a name="BboxTransformFrom-transform_point"><strong>transform_point</strong></a>(self, point)</dt></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>Create a new transformation matrix as a 3x3 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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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>BboxTransformSimple linearly transforms points from the unit <a href="#Bbox">Bbox</a><br>
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#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 <a href="#BboxTransform">BboxTransform</a> that linearly transforms points<br>
from the unit <a href="#Bbox">Bbox</a> 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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</tt></dd></dl>
<dl><dt><a name="BboxTransformTo-transform_point"><strong>transform_point</strong></a>(self, point)</dt></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>Create a new transformation matrix as a 3x3 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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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 blended_transform_factory function instead, which can<br>
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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</tt></dd></dl>
<dl><dt><a name="BlendedAffine2D-transform_point"><strong>transform_point</strong></a>(self, point)</dt></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>Create a new transformation matrix as a 3x3 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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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 blended_transform_factory function instead, which can<br>
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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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 self.<strong>input_dims</strong>.<br>
The transformed point is returned as a sequence of length<br>
self.<strong>output_dims</strong>.</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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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 <a href="#Affine2DBase">Affine2DBase</a>.<br>
<br>
You will generally not call this constructor directly but use<br>
the composite_transform_factory function instead, which can<br>
automatically choose the best kind of composite transform<br>
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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</tt></dd></dl>
<dl><dt><a name="CompositeAffine2D-transform_point"><strong>transform_point</strong></a>(self, point)</dt></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>Create a new transformation matrix as a 3x3 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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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 composite_transform_factory function instead, which can<br>
automatically choose the best kind of composite transform<br>
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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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 self.<strong>input_dims</strong>.<br>
The transformed point is returned as a sequence of length<br>
self.<strong>output_dims</strong>.</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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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>Create a new transformation matrix as a 3x3 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></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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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><td bgcolor="#ffc8d8"><tt> </tt></td><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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</tt></dd></dl>
<dl><dt><a name="ScaledTranslation-transform_point"><strong>transform_point</strong></a>(self, point)</dt></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>Create a new transformation matrix as a 3x3 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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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></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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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 subclass this class. New<br>
affine transformations should subclass <a href="#Affine2D">Affine2D</a>.<br>
<br>
Subclasses of this class should override the following members (at<br>
minimum):<br>
<br>
input_dims<br>
output_dims<br>
transform<br>
is_separable<br>
has_inverse<br>
inverted (if has_inverse will return True)<br>
<br>
If the transform needs to do something non-standard with Paths,<br>
such as adding curves where there were once line segments, it<br>
should override:<br>
<br>
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></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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 self.<strong>input_dims</strong>.<br>
The transformed point is returned as a sequence of length<br>
self.<strong>output_dims</strong>.</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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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><a href="#TransformNode">TransformNode</a> is the base class for anything that participates in<br>
the transform tree and needs to invalidate its parents or be<br>
invalidated. It can include classes that are not technically<br>
transforms, such as bounding boxes, since some transforms depend<br>
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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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 <a href="#TransformWrapper">TransformWrapper</a> instances must have the same input and<br>
output dimensions during their entire lifetime, so the child<br>
transform may only be replaced with another child transform of the<br>
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 <a href="#TransformWrapper-set">set</a>().</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></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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 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 a<br>
no-op.<br>
<br>
Accepts a numpy array of shape (N x self.<strong>input_dims</strong>) and<br>
returns a numpy array of shape (N x self.<strong>output_dims</strong>).</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 self.<strong>input_dims</strong>.<br>
The transformed point is returned as a sequence of length<br>
self.<strong>output_dims</strong>.</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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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 <a href="#Bbox">Bbox</a> that is automatically transformed by a given <a href="#Transform">Transform</a>. When<br>
either the child bbox or transform changes, the bounds of this bbox<br>
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>
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></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 a) 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>
or b) a string: C for centered, S for bottom-center, SE for<br>
bottom-left, E for left, etc.<br>
<br>
Optional arg container is the box within which the BBox<br>
is positioned; it defaults to the initial BBox.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-contains"><strong>contains</strong></a>(self, x, y)</dt></dl>
<dl><dt><a name="TransformedBbox-containsx"><strong>containsx</strong></a>(self, x)</dt></dl>
<dl><dt><a name="TransformedBbox-containsy"><strong>containsy</strong></a>(self, y)</dt></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.</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 <a href="#Bbox">Bbox</a> objects</tt></dd></dl>
<dl><dt><a name="TransformedBbox-expanded"><strong>expanded</strong></a>(self, sw, sh)</dt><dd><tt>Return a new <a href="#Bbox">Bbox</a> which is this <a href="#Bbox">Bbox</a> expanded around its<br>
center by the given factors sw and sh.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-frozen"><strong>frozen</strong></a>(self)</dt><dd><tt><a href="#TransformNode">TransformNode</a> is the base class for anything that participates in<br>
the transform tree and needs to invalidate its parents or be<br>
invalidated. It can include classes that are not technically<br>
transforms, such as bounding boxes, since some transforms depend<br>
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></dl>
<dl><dt><a name="TransformedBbox-fully_containsx"><strong>fully_containsx</strong></a>(self, x)</dt></dl>
<dl><dt><a name="TransformedBbox-fully_containsy"><strong>fully_containsy</strong></a>(self, y)</dt></dl>
<dl><dt><a name="TransformedBbox-fully_overlaps"><strong>fully_overlaps</strong></a>(self, other)</dt></dl>
<dl><dt><a name="TransformedBbox-inverse_transformed"><strong>inverse_transformed</strong></a>(self, transform)</dt><dd><tt>Return a new <a href="#Bbox">Bbox</a> <a href="__builtin__.html#object">object</a>, transformed by the inverse of the<br>
given transform.</tt></dd></dl>
<dl><dt><a name="TransformedBbox-is_unit"><strong>is_unit</strong></a>(self)</dt></dl>
<dl><dt><a name="TransformedBbox-overlaps"><strong>overlaps</strong></a>(self, other)</dt></dl>
<dl><dt><a name="TransformedBbox-padded"><strong>padded</strong></a>(self, p)</dt><dd><tt>Return a new <a href="#Bbox">Bbox</a> that is padded on all four sides by the<br>
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 this<br>
bounding box. The new bounding box is still aligned with the<br>
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 <a href="#Bbox">Bbox</a>, shurnk by the factor mx in the x<br>
direction and the factor my in the y direction. The lower<br>
left corner of the box remains unchanged. Normally mx and my<br>
will be <= 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 <a href="#Bbox">Bbox</a>, shrunk so that it is as large as it<br>
can be while having the desired aspect ratio, box_aspect. If<br>
the box coordinates are relative--that is, fractions of a<br>
larger box such as a figure--then the physical aspect ratio of<br>
that figure is specified with fig_aspect, so that box_aspect<br>
can also be given as a ratio of the absolute dimensions, not<br>
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 BBoxes formed by<br>
splitting the original one with vertical lines<br>
at fractional 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 PBoxes formed by<br>
splitting the original one with horizontal lines<br>
at fractional positions f1, f2, ...</tt></dd></dl>
<dl><dt><a name="TransformedBbox-transformed"><strong>transformed</strong></a>(self, transform)</dt><dd><tt>Return a new <a href="#Bbox">Bbox</a> <a href="__builtin__.html#object">object</a>, transformed by 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 <a href="#Bbox">Bbox</a>, translated by 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 <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>
</dl>
<dl><dt><strong>extents</strong></dt>
</dl>
<dl><dt><strong>height</strong></dt>
</dl>
<dl><dt><strong>intervalx</strong></dt>
</dl>
<dl><dt><strong>intervaly</strong></dt>
</dl>
<dl><dt><strong>max</strong></dt>
</dl>
<dl><dt><strong>min</strong></dt>
</dl>
<dl><dt><strong>p0</strong></dt>
</dl>
<dl><dt><strong>p1</strong></dt>
</dl>
<dl><dt><strong>size</strong></dt>
</dl>
<dl><dt><strong>width</strong></dt>
</dl>
<dl><dt><strong>x0</strong></dt>
</dl>
<dl><dt><strong>x1</strong></dt>
</dl>
<dl><dt><strong>xmax</strong></dt>
</dl>
<dl><dt><strong>xmin</strong></dt>
</dl>
<dl><dt><strong>y0</strong></dt>
</dl>
<dl><dt><strong>y1</strong></dt>
</dl>
<dl><dt><strong>ymax</strong></dt>
</dl>
<dl><dt><strong>ymin</strong></dt>
</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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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>
<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 parents. Should<br>
be called anytime 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. Should be called from the<br>
constructor of any transforms that 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>
Shortcut versions of the blended transform are provided for the<br>
case 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 TransformNodes may also be created using the '+' operator, 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="-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@
