| Server IP : 202.61.199.114 / Your IP : 216.73.217.139 Web Server : nginx/1.22.1 System : Linux de.arni-solutions.de 6.1.0-49-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.174-1 (2026-05-26) x86_64 User : web20 ( 1018) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /usr/local/lib/python3.9/dist-packages/matplotlib/__pycache__/ |
Upload File : |
a
���h�� � @ sV d Z ddlZddlZddlZddlZddlZddlZddlm Z ddl
m Z ddl m
Z
mZmZ ddlmZ dZd d
� ZG d d � d �ZG d
d� de�Ze�ejejg�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�Z G dd� de �Z G dd� de �Z G dd � d e �Z G d d � d e �Z G d d � d e �Z!G d!d"� d"�Z"G d#d$� d$e"e �Z#G d%d&� d&e"e �Z$d'd(� Z%G d)d*� d*e �Z&G d+d,� d,e �Z'd-d.� Z(G d/d0� d0e �Z)G d1d2� d2e �Z*e �+d3�G d4d5� d5e*��Z,G d6d7� d7e �Z-G d8d9� d9e �Z.G d:d;� d;e �Z/G d<d=� d=e�Z0G d>d?� d?e0�Z1dPdCdD�Z2dEdF� Z3dQdHdI�Z4dJdK� Z5dRdNdO�Z6dS )Sa
Matplotlib includes a framework for arbitrary geometric
transformations that is used determine the final position of all
elements drawn on the canvas.
Transforms are composed into trees of `TransformNode` objects
whose actual value depends on their children. When the contents of
children change, their parents are automatically invalidated. The
next time an invalidated transform is accessed, it is recomputed to
reflect those changes. This invalidation/caching approach prevents
unnecessary recomputations of transforms, and contributes to better
interactive performance.
For example, here is a graph of the transform tree used to plot data
to the graph:
.. image:: ../_static/transforms.png
The framework can be used for both affine and non-affine
transformations. However, for speed, we want to use the backend
renderers to perform affine transformations whenever possible.
Therefore, it is possible to perform just the affine or non-affine
part of a transformation on a set of data. The affine is always
assumed to occur after the non-affine. For any transform::
full transform == non-affine part + affine part
The backends are not expected to handle non-affine transformations
themselves.
See the tutorial :ref:`transforms_tutorial` for examples
of how to use transforms.
� N)�inv)�_api)�affine_transform� count_bboxes_overlapping_bbox�update_path_extents� )�PathFc s* t jtjdd��dd� �� ���fdd�S )a+
Generate a ``__str__`` method for a `.Transform` subclass.
After ::
class T:
__str__ = _make_str_method("attr", key="other")
``str(T(...))`` will be
.. code-block:: text
{type(T).__name__}(
{self.attr},
key={self.other})
z )�prefixc S s t | t�rt| �S t| �S �N)�
isinstance�str�repr)�x� r �?/usr/local/lib/python3.9/dist-packages/matplotlib/transforms.py�strreprJ � z!_make_str_method.<locals>.strreprc sL t � �jd d�g �� �fdd��D ���� �fdd���� D ��� d S )N�(�,c 3 s$ | ] }� d �t �|�� �V qdS )�
N��getattr)�.0�arg��indent�selfr r r � <genexpr>M s �z5_make_str_method.<locals>.<lambda>.<locals>.<genexpr>c 3 s0 | ](\}}� d | d �t �|�� �V qdS )r �=Nr )r �kr r r r r O s ��))�type�__name__�join�items�r ��argsr �kwargsr r% r �<lambda>K s �����z"_make_str_method.<locals>.<lambda>)� functools�partial�textwrapr )r' r( r r& r �_make_str_method8 s r- c s� e Zd ZdZe�d�e�dd� ��Ze�d�e�dd� ��Ze�d�e�dd� ��Z e
d�\Z Z Z
dZe�d �e�d
d� ��ZdZd d d
�Zer�dd� Zdd� Zdd� Z� fdd�Zdd� Zdd� Zdd� Zd d � Z� ZS ) �
TransformNodea'
The base class for anything that participates in the transform tree
and needs to invalidate its parents or be invalidated. This includes
classes that are not really transforms, such as bounding boxes, since some
transforms depend on bounding boxes to compute their values.
�3.8c C s dS �Nr r ��clsr r r r) _ r zTransformNode.<lambda>c C s dS �N� r r1 r r r r) ` r c C s dS )N� r r1 r r r r) a r r5 F�3.9c C s dS �NFr r1 r r r r) i r Nc C s i | _ | j| _|pd| _dS )a
Parameters
----------
shorthand_name : str
A string representing the "name" of the transform. The name carries
no significance other than to improve the readability of
``str(transform)`` when DEBUG=True.
� N)�_parents�
_INVALID_FULL�_invalid�_shorthand_name)r �shorthand_namer r r �__init__q s zTransformNode.__init__c C s | j p t| �S r
)r< r
r% r r r �__str__� s zTransformNode.__str__c C s" i | j �ddd� | j�� D �i�S )Nr9 c S s i | ]\}}||� �qS r r �r r �vr r r �
<dictcomp>� r z.TransformNode.__getstate__.<locals>.<dictcomp>��__dict__r9 r$ r% r r r � __getstate__� s �zTransformNode.__getstate__c s$ |� _ � fdd�� j�� D �� _d S )Nc s4 i | ],\}}|d ur|t �|� jj|fdd���qS )Nc S s ||�S r
r ��_�popr r r r r) � r z7TransformNode.__setstate__.<locals>.<dictcomp>.<lambda>)�weakref�refr9 rH r@ r% r r rB � s �z.TransformNode.__setstate__.<locals>.<dictcomp>rC )r Z data_dictr r% r � __setstate__� s
�zTransformNode.__setstate__c sN t � t� �}i |_t| ��� D ]*\}}t|t�r t| �|jv r |�|� q |S r
) �copy�superr9 �varsr$ r r. �id� set_children)r �other�key�val�� __class__r r �__copy__� s zTransformNode.__copy__c C s | j | jr| jn| j| d�S )z�
Invalidate this `TransformNode` and triggers an invalidation of its
ancestors. Should be called any time the transform changes.
��level�invalidating_node)�_invalidate_internal� is_affine�_INVALID_AFFINE_ONLYr: r% r r r �
invalidate� s �zTransformNode.invalidatec C sN || j kr| jsdS || _ t| j�� �D ] }|� }|dur(|j|| d� q(dS )z�
Called by :meth:`invalidate` and subsequently ascends the transform
stack calling each TransformNode's _invalidate_internal method.
NrW )r; � pass_through�listr9 �valuesrZ )r rX rY �parentr r r rZ � s z"TransformNode._invalidate_internalc G s: t | �}|D ](}t�| |jj|fdd��}||j|< q dS )z�
Set the children of the transform, to let the invalidation
system know which transforms can invalidate this transform.
Should be called from the constructor of any transforms that
depend on other transforms.
c S s ||�S r
r rF r r r r) � r z,TransformNode.set_children.<locals>.<lambda>N)rO rI rJ r9 rH )r �childrenZid_self�childrJ r r r rP � s
�zTransformNode.set_childrenc C s | S )a
Return a frozen copy of this transform node. The frozen copy will not
be updated when its children change. Useful for storing a previously
known state of a transform where ``copy.deepcopy()`` might normally be
used.
r r% r r r �frozen� s zTransformNode.frozen)N) r" �
__module__� __qualname__�__doc__r �
deprecated�
classpropertyZINVALID_NON_AFFINEZINVALID_AFFINE�INVALID�rangeZ_VALIDr\ r: r[ �is_bboxr^ r> �DEBUGr? rE rK rV r] rZ rP rd �
__classcell__r r rT r r. T s$
r. c
@ s, e Zd ZdZe�d�e�dd� ��ZdZe r8e
dd� �Z dd � Z e
je _d
d � Zed d
� �Zedd� �Zedd� �Zedd� �Zedd� �Zedd� �Zedd� �Zedd� �Zed d � �Zed d � �Zed d!� �Zed"d#� �Zed$d%� �Z ed&d'� �Z ed(d)� �Z ed*d+� �Z ed,d-� �Z ed.d/� �Z!ed0d1� �Z"d2d3� Z#d4d5� Z$d6d7� Z%d8d9� Z&d:d;� Z'd<d=� Z(d>d?� Z)d@dA� Z*dBdC� Z+dDdE� Z,dFdGdHdIdJdKdLdMdNdO� Z-dqdQdR�Z.dSdT� Z/drdVdW�Z0dXdY� Z1dZd[� Z2d\d]� Z3d^d_� Z4d`da� Z5e�6dbdcdd�dsdedf��Z7dgdh� Z8didj� Z9dkdl� Z:e
dmdn� �Z;e
dodp� �Z<dPS )t�BboxBasea`
The base class of all bounding boxes.
This class is immutable; `Bbox` is a mutable subclass.
The canonical representation is as two points, with no
restrictions on their ordering. Convenience properties are
provided to get the left, bottom, right and top edges and width
and height, but these are not stored explicitly.
r6 c C s dS )NTr r1 r r r r) � r zBboxBase.<lambda>Tc C sX t | tjj�rt�d� t�| �} t| dd d �f | dd d �f dk�rTt�d� d S )Nz Bbox bounds are a masked array.r r zSingular Bbox.)r �np�ma� MaskedArrayr �
warn_external�asarray�any)�pointsr r r �_check� s
(zBboxBase._checkc C s t | �� �� �S r
)�Bbox�
get_pointsrL r% r r r rd � s zBboxBase.frozenc O s | � � S r
�ry �r r' r( r r r � __array__� s zBboxBase.__array__c C s | � � d S )z�
The first of the pair of *x* coordinates that define the bounding box.
This is not guaranteed to be less than :attr:`x1` (for that, use
:attr:`xmin`).
�r r rz r% r r r �x0� s z BboxBase.x0c C s | � � d S )z�
The first of the pair of *y* coordinates that define the bounding box.
This is not guaranteed to be less than :attr:`y1` (for that, use
:attr:`ymin`).
�r r rz r% r r r �y0� s z BboxBase.y0c C s | � � d S )z�
The second of the pair of *x* coordinates that define the bounding box.
This is not guaranteed to be greater than :attr:`x0` (for that, use
:attr:`xmax`).
�r r rz r% r r r �x1 s z BboxBase.x1c C s | � � d S )z�
The second of the pair of *y* coordinates that define the bounding box.
This is not guaranteed to be greater than :attr:`y0` (for that, use
:attr:`ymax`).
�r r rz r% r r r �y1 s z BboxBase.y1c C s | � � d S )z�
The first pair of (*x*, *y*) coordinates that define the bounding box.
This is not guaranteed to be the bottom-left corner (for that, use
:attr:`min`).
r rz r% r r r �p0 s z BboxBase.p0c C s | � � d S )z�
The second pair of (*x*, *y*) coordinates that define the bounding box.
This is not guaranteed to be the top-right corner (for that, use
:attr:`max`).
r rz r% r r r �p1$ s z BboxBase.p1c C s t �| �� dd�df �S )z"The left edge of the bounding box.Nr �rp �minry r% r r r �xmin. s z
BboxBase.xminc C s t �| �� dd�df �S )z$The bottom edge of the bounding box.Nr r� r% r r r �ymin3 s z
BboxBase.yminc C s t �| �� dd�df �S )z#The right edge of the bounding box.Nr �rp �maxry r% r r r �xmax8 s z
BboxBase.xmaxc C s t �| �� dd�df �S )z!The top edge of the bounding box.Nr r� r% r r r �ymax= s z
BboxBase.ymaxc C s t j| �� dd�S )z+The bottom-left corner of the bounding box.r �Zaxisr� r% r r r r� B s z BboxBase.minc C s t j| �� dd�S )z)The top-right corner of the bounding box.r r� r� r% r r r r� G s z BboxBase.maxc C s | � � dd�df S )z�
The pair of *x* coordinates that define the bounding box.
This is not guaranteed to be sorted from left to right.
Nr rz r% r r r � intervalxL s zBboxBase.intervalxc C s | � � dd�df S )z�
The pair of *y* coordinates that define the bounding box.
This is not guaranteed to be sorted from bottom to top.
Nr rz r% r r r � intervalyU s zBboxBase.intervalyc C s | � � }|d |d S )z'The (signed) width of the bounding box.r� r} rz �r rv r r r �width^ s zBboxBase.widthc C s | � � }|d |d S )z(The (signed) height of the bounding box.r� r rz r� r r r �heightd s zBboxBase.heightc C s | � � }|d |d S )z2The (signed) width and height of the bounding box.r r rz r� r r r �sizej s z
BboxBase.sizec C s( | � � \\}}\}}|||| || fS )z?Return (:attr:`x0`, :attr:`y0`, :attr:`width`, :attr:`height`).rz �r r~ r� r� r� r r r �boundsp s zBboxBase.boundsc C s | � � �� S )z8Return (:attr:`x0`, :attr:`y0`, :attr:`x1`, :attr:`y1`).)ry �flattenr% r r r �extentsv s zBboxBase.extentsc C s t �d S r
��NotImplementedErrorr% r r r ry { s zBboxBase.get_pointsc C s: | j \}}|| ko |kn p8|| ko4|kS S )zX
Return whether *x* is in the closed (:attr:`x0`, :attr:`x1`) interval.
�r� �r r r~ r� r r r � containsx~ s
zBboxBase.containsxc C s: | j \}}|| ko |kn p8|| ko4|kS S )zX
Return whether *y* is in the closed (:attr:`y0`, :attr:`y1`) interval.
�r� �r �yr� r� r r r � containsy� s
zBboxBase.containsyc C s | � |�o| �|�S )zR
Return whether ``(x, y)`` is in the bounding box or on its edge.
)r� r� �r r r� r r r �contains� s zBboxBase.containsc
C s� | j \}}}}|j \}}}} ||k r.|| }}||k r@|| }}||k rR|| }}| |k rd|| } }||ko�||ko�|| ko�||kS )z�
Return whether this bounding box overlaps with the other bounding box.
Parameters
----------
other : `.BboxBase`
�r� �
r rQ Zax1Zay1Zax2Zay2Zbx1Zby1Zbx2Zby2r r r �overlaps� s
zBboxBase.overlapsc C s: | j \}}|| k o |k n p8|| ko4|kS S )zV
Return whether *x* is in the open (:attr:`x0`, :attr:`x1`) interval.
r� r� r r r �fully_containsx� s
zBboxBase.fully_containsxc C s: | j \}}|| k o |k n p8|| ko4|kS S )zV
Return whether *y* is in the open (:attr:`y0`, :attr:`y1`) interval.
r� r� r r r �fully_containsy� s
zBboxBase.fully_containsyc C s | � |�o| �|�S )zV
Return whether ``x, y`` is in the bounding box, but not on its edge.
)r� r� r� r r r �fully_contains� s zBboxBase.fully_containsc
C s� | j \}}}}|j \}}}} ||k r.|| }}||k r@|| }}||k rR|| }}| |k rd|| } }||k o�||k o�|| k o�||k S )z�
Return whether this bounding box overlaps with the other bounding box,
not including the edges.
Parameters
----------
other : `.BboxBase`
r� r� r r r �fully_overlaps� s
zBboxBase.fully_overlapsc C sX | � � }|�t�|d |d |d g|d |d gg��\}}}t||d |d gg�S )zX
Construct a `Bbox` by statically transforming this one by *transform*.
r r} r� r� r r )ry � transformrp �arrayrx )r r� �ptsZll�ul�lrr r r � transformed� s
$� zBboxBase.transformed)� �?r� r} )r� r )� �?r )r� r� )r� r� )r� r� )r r� )r r� ) �CZSW�SZSE�EZNE�NZNW�WNc
C s� |du rt jddd� | }|j\}}}}| j\}}} }
t|t�rJ| j| n|\} } t| j|| || | || ||
| g �S )a(
Return a copy of the `Bbox` anchored to *c* within *container*.
Parameters
----------
c : (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', ...}
Either an (*x*, *y*) pair of relative coordinates (0 is left or
bottom, 1 is right or top), 'C' (center), or a cardinal direction
('SW', southwest, is bottom left, etc.).
container : `Bbox`, optional
The box within which the `Bbox` is positioned.
See Also
--------
.Axes.set_anchor
Nr/ zwCalling anchored() with no container bbox returns a frozen copy of the original bbox and is deprecated since %(since)s.)�message)r Zwarn_deprecatedr� r r �coefsrx �_points)
r �c� container�l�b�w�h�L�Br� �HZcx�cyr r r �anchored� s � ��zBboxBase.anchoredc C s2 | j \}}t| jd | jd || || g g�S )a
Return a copy of the `Bbox`, shrunk by the factor *mx*
in the *x* direction and the factor *my* in the *y* direction.
The lower left corner of the box remains unchanged. Normally
*mx* and *my* will be less than 1, but this is not enforced.
r )r� rx r� )r ZmxZmyr� r� r r r �shrunk s
�zBboxBase.shrunkr� c C sx |dks|dkrt d��|du r$| }|j\}}|| | }||krH|}n|| | }|}t| jd | jd ||f g�S )a�
Return a copy of the `Bbox`, shrunk so that it is as
large as it can be while having the desired aspect ratio,
*box_aspect*. If the box coordinates are relative (i.e.
fractions of a larger box such as a figure) then the
physical aspect ratio of that figure is specified with
*fig_aspect*, so that *box_aspect* can also be given as a
ratio of the absolute dimensions, not the relative dimensions.
r z.'box_aspect' and 'fig_aspect' must be positiveN)�
ValueErrorr� rx r� )r Z
box_aspectr� Z
fig_aspectr� r� r� r� r r r �shrunk_to_aspect s
�zBboxBase.shrunk_to_aspectc sR dg|�d�}| j \��}�|� � � ���fdd�t|dd� |dd� �D �S )z�
Return a list of new `Bbox` objects formed by splitting the original
one with vertical lines at fractional positions given by *args*.
r r c s4 g | ],\}}t �|� �g�|� �gg��qS r �rx )r Zxf0Zxf1�r� r~ r� r� r r �
<listcomp>+ s �z#BboxBase.splitx.<locals>.<listcomp>N����r� �zip)r r' Zxfr� r r� r �splitx# s �zBboxBase.splitxc sR dg|�d�}| j \���}|� � � ���fdd�t|dd� |dd� �D �S )z�
Return a list of new `Bbox` objects formed by splitting the original
one with horizontal lines at fractional positions given by *args*.
r r c s4 g | ],\}}t ��|� g��|� gg��qS r r� )r Zyf0Zyf1�r� r~ r� r� r r r� 6 s �z#BboxBase.splity.<locals>.<listcomp>Nr� r� )r r' Zyfr� r r� r �splity. s �zBboxBase.splityc C sj t |�dkrdS t�|�}tjdd��0 | j|k || jk @ jdd��� W d � S 1 s\0 Y dS )z�
Count the number of vertices contained in the `Bbox`.
Any vertices with a non-finite x or y value are ignored.
Parameters
----------
vertices : (N, 2) array
r �ignore)�invalidr r� N)�lenrp rt Zerrstater� r� �all�sum)r �verticesr r r �count_contains9 s
��zBboxBase.count_containsc C s t | t�dd� |D ���S )z�
Count the number of bounding boxes that overlap this one.
Parameters
----------
bboxes : sequence of `.BboxBase`
c S s g | ]}t �|��qS r )rp r� )r r r r r r� R r z+BboxBase.count_overlaps.<locals>.<listcomp>)r rp Z
atleast_3d)r �bboxesr r r �count_overlapsI s �zBboxBase.count_overlapsc C sT | j }| j}|| | d }|| | d }t�| | g||gg�}t| j| �S )zr
Construct a `Bbox` by expanding this one around its center by the
factors *sw* and *sh*.
g @)r� r� rp r� rx r� )r �sw�shr� r� ZdeltawZdeltah�ar r r �expandedT s zBboxBase.expandedr/ �p�w_padc C s0 | � � }|du r|}t|| | g||gg �S )z�
Construct a `Bbox` by padding this one on all four sides.
Parameters
----------
w_pad : float
Width pad
h_pad : float, optional
Height pad. Defaults to *w_pad*.
N)ry rx )r r� Zh_padrv r r r �padded` s
zBboxBase.paddedc C s t | j||f �S )z<Construct a `Bbox` by translating this one by *tx* and *ty*.)rx r� �r Ztx�tyr r r �
translatedr s zBboxBase.translatedc C s6 | � � \\}}\}}t�||g||g||g||gg�S )z�
Return the corners of this rectangle as an array of points.
Specifically, this returns the array
``[[x0, y0], [x0, y1], [x1, y0], [x1, y1]]``.
)ry rp r� r� r r r �cornersv s zBboxBase.cornersc C s4 | � � }t� �|��|�}t�� }|j|dd� |S )z�
Return the axes-aligned bounding box that bounds the result of rotating
this `Bbox` by an angle of *radians*.
T)r� )r� �Affine2D�rotater� rx �unit�update_from_data_xy)r �radiansr� Zcorners_rotated�bboxr r r �rotated� s
zBboxBase.rotatedc C st t | �std��t�dd� | D ��}t�dd� | D ��}t�dd� | D ��}t�dd� | D ��}t||g||gg�S )z8Return a `Bbox` that contains all of the given *bboxes*.z'bboxes' cannot be emptyc S s g | ]
}|j �qS r )r� �r r� r r r r� � r z"BboxBase.union.<locals>.<listcomp>c S s g | ]
}|j �qS r )r� r� r r r r� � r c S s g | ]
}|j �qS r )r� r� r r r r� � r c S s g | ]
}|j �qS r )r� r� r r r r� � r )r� r� rp r� r� rx )r� r~ r� r� r� r r r �union� s zBboxBase.unionc C sh t �| j|j�}t �| j|j�}t �| j|j�}t �| j|j�}||krd||krdt||g||gg�S dS )zr
Return the intersection of *bbox1* and *bbox2* if they intersect, or
None if they don't.
N)rp �maximumr� Zminimumr� r� r� rx )Zbbox1Zbbox2r~ r� r� r� r r r � intersection� s
zBboxBase.intersection)N)Nr� )N)=r" re rf rg r rh ri rl r[ rm � staticmethodrw rd r. r| �propertyr~ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� ry r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� �rename_parameterr� r� r� r� r� r� r r r r ro � s�
�
ro c s� e Zd ZdZ� fdd�Zer4eZdd� Z� fdd�Z� fdd�Ze d d
� �Z
e d d � �Z e d
d� �Z e dd�dd��Z
dd� Zdd� Zdd� Zdd� ZdKd d �ZdLd d �ZdMd d!�ZdNd"d#�Zejjd$d%� �Zejjd&d'� �Zejjd(d)� �Zejjd*d+� �Zej jd,d-� �Z ej jd.d/� �Z ej jd0d1� �Z ej jd2d3� �Z ej jd4d5� �Z e!d6d7� �Z"e"jd8d7� �Z"e!d9d:� �Z#e#jd;d:� �Z#e!d<d=� �Z$e$jd>d=� �Z$d?d@� Z%dAdB� Z&dCdD� Z'dEdF� Z(dGdH� Z)dIdJ� Z*� Z+S )Orx a�
A mutable bounding box.
Examples
--------
**Create from known bounds**
The default constructor takes the boundary "points" ``[[xmin, ymin],
[xmax, ymax]]``.
>>> Bbox([[1, 1], [3, 7]])
Bbox([[1.0, 1.0], [3.0, 7.0]])
Alternatively, a Bbox can be created from the flattened points array, the
so-called "extents" ``(xmin, ymin, xmax, ymax)``
>>> Bbox.from_extents(1, 1, 3, 7)
Bbox([[1.0, 1.0], [3.0, 7.0]])
or from the "bounds" ``(xmin, ymin, width, height)``.
>>> Bbox.from_bounds(1, 1, 2, 6)
Bbox([[1.0, 1.0], [3.0, 7.0]])
**Create from collections of points**
The "empty" object for accumulating Bboxs is the null bbox, which is a
stand-in for the empty set.
>>> Bbox.null()
Bbox([[inf, inf], [-inf, -inf]])
Adding points to the null bbox will give you the bbox of those points.
>>> box = Bbox.null()
>>> box.update_from_data_xy([[1, 1]])
>>> box
Bbox([[1.0, 1.0], [1.0, 1.0]])
>>> box.update_from_data_xy([[2, 3], [3, 2]], ignore=False)
>>> box
Bbox([[1.0, 1.0], [3.0, 3.0]])
Setting ``ignore=True`` is equivalent to starting over from a null bbox.
>>> box.update_from_data_xy([[1, 1]], ignore=True)
>>> box
Bbox([[1.0, 1.0], [1.0, 1.0]])
.. warning::
It is recommended to always specify ``ignore`` explicitly. If not, the
default value of ``ignore`` can be changed at any time by code with
access to your Bbox, for example using the method `~.Bbox.ignore`.
**Properties of the ``null`` bbox**
.. note::
The current behavior of `Bbox.null()` may be surprising as it does
not have all of the properties of the "empty set", and as such does
not behave like a "zero" object in the mathematical sense. We may
change that in the future (with a deprecation period).
The null bbox is the identity for intersections
>>> Bbox.intersection(Bbox([[1, 1], [3, 7]]), Bbox.null())
Bbox([[1.0, 1.0], [3.0, 7.0]])
except with itself, where it returns the full space.
>>> Bbox.intersection(Bbox.null(), Bbox.null())
Bbox([[-inf, -inf], [inf, inf]])
A union containing null will always return the full space (not the other
set!)
>>> Bbox.union([Bbox([[0, 0], [0, 0]]), Bbox.null()])
Bbox([[-inf, -inf], [inf, inf]])
c sV t � jf i |�� t�|t�}|jdkr0td��|| _t� � | _
d| _ | j� � | _ dS )z�
Parameters
----------
points : `~numpy.ndarray`
A (2, 2) array of the form ``[[x0, y0], [x1, y1]]``.
�r4 r4 z7Bbox points must be of the form "[[x0, y0], [x1, y1]]".TN)
rM r> rp rt �float�shaper� r� �_default_minposrL �_minpos�_ignore� _points_orig�r rv r( rT r r r> � s
z
Bbox.__init__c K s | � |� | j|fi |�� d S r
)rw � ___init__r� r r r r>
s
c s | � | j� t� �� d S r
)rw r� rM r] r% rT r r r] s zBbox.invalidatec s t � �� }| j�� |_|S r
)rM rd �minposrL r� )r Z frozen_bboxrT r r rd s
z Bbox.frozenc C s t ddgddgg�S )z/Create a new unit `Bbox` from (0, 0) to (1, 1).r r r� r r r r r� s z Bbox.unitc C s t tjtjgtj tj gg�S )z9Create a new null `Bbox` from (inf, inf) to (-inf, -inf).)rx rp �infr r r r �null s z Bbox.nullc C s t �| || | || �S )z{
Create a new `Bbox` from *x0*, *y0*, *width* and *height*.
*width* and *height* may be negative.
)rx � from_extents)r~ r� r� r� r r r � from_bounds% s zBbox.from_boundsN)r� c G s* t t�|d��}| dur&| |jdd�< |S )a�
Create a new Bbox from *left*, *bottom*, *right* and *top*.
The *y*-axis increases upwards.
Parameters
----------
left, bottom, right, top : float
The four extents of the bounding box.
minpos : float or None
If this is supplied, the Bbox will have a minimum positive value
set. This is useful when dealing with logarithmic scales and other
scales where negative bounds result in floating point errors.
r� N)rx rp �reshaper� )r� r' r� r r r r . s zBbox.from_extentsc C s d� | |�S )Nz@Bbox(x0={0.x0:{1}}, y0={0.y0:{1}}, x1={0.x1:{1}}, y1={0.y1:{1}})��format)r �fmtr r r �
__format__C s ��zBbox.__format__c C s
t | d�S )Nr8 r r% r r r r? H s z Bbox.__str__c C s
d� | �S )Nz*Bbox([[{0.x0}, {0.y0}], [{0.x1}, {0.y1}]])r r% r r r �__repr__K s z
Bbox.__repr__c C s
|| _ dS )a�
Set whether the existing bounds of the box should be ignored
by subsequent calls to :meth:`update_from_data_xy`.
value : bool
- When ``True``, subsequent calls to `update_from_data_xy` will
ignore the existing bounds of the `Bbox`.
- When ``False``, subsequent calls to `update_from_data_xy` will
include the existing bounds of the `Bbox`.
N)r� )r �valuer r r r� N s z Bbox.ignoreTc C s� |du r| j }|jjdkr dS t|d| j| j|�\}}}|r�| �� |rt|dd�df | jdd�df< |d | jd< |r�|dd�df | jdd�df< |d | jd< dS )a�
Update the bounds of the `Bbox` to contain the vertices of the
provided path. After updating, the bounds will have positive *width*
and *height*; *x0* and *y0* will be the minimal values.
Parameters
----------
path : `~matplotlib.path.Path`
ignore : bool, optional
- When ``True``, ignore the existing bounds of the `Bbox`.
- When ``False``, include the existing bounds of the `Bbox`.
- When ``None``, use the last value passed to :meth:`ignore`.
updatex, updatey : bool, default: True
When ``True``, update the x/y values.
Nr r )r� r� r� r r� r� r] )r �pathr� �updatex�updateyrv r� �changedr r r �update_from_path[ s �
zBbox.update_from_pathc C s0 t �|�}| jt �|t �|j�g�|dd� dS )a
Update the x-bounds of the `Bbox` based on the passed in data. After
updating, the bounds will have positive *width*, and *x0* will be the
minimal value.
Parameters
----------
x : `~numpy.ndarray`
Array of x-values.
ignore : bool, optional
- When ``True``, ignore the existing bounds of the `Bbox`.
- When ``False``, include the existing bounds of the `Bbox`.
- When ``None``, use the last value passed to :meth:`ignore`.
F)r� r N�rp Zravelr� � column_stackZonesr� )r r r� r r r �update_from_data_x} s
�zBbox.update_from_data_xc C s0 t �|�}| jt �t �|j�|g�|dd� dS )a
Update the y-bounds of the `Bbox` based on the passed in data. After
updating, the bounds will have positive *height*, and *y0* will be the
minimal value.
Parameters
----------
y : `~numpy.ndarray`
Array of y-values.
ignore : bool, optional
- When ``True``, ignore the existing bounds of the `Bbox`.
- When ``False``, include the existing bounds of the `Bbox`.
- When ``None``, use the last value passed to :meth:`ignore`.
F)r� r Nr )r r� r� r r r �update_from_data_y� s
�zBbox.update_from_data_yc C s. t |�dkrdS t|�}| j||||d� dS )a�
Update the `Bbox` bounds based on the passed in *xy* coordinates.
After updating, the bounds will have positive *width* and *height*;
*x0* and *y0* will be the minimal values.
Parameters
----------
xy : (N, 2) array-like
The (x, y) coordinates.
ignore : bool, optional
- When ``True``, ignore the existing bounds of the `Bbox`.
- When ``False``, include the existing bounds of the `Bbox`.
- When ``None``, use the last value passed to :meth:`ignore`.
updatex, updatey : bool, default: True
When ``True``, update the x/y values.
r N)r� r r )r� r r )r �xyr� r r r
r r r r� � s �zBbox.update_from_data_xyc C s || j d< | �� d S �Nr} �r� r] �r rS r r r r~ � s
zBbox.x0c C s || j d< | �� d S �Nr r r r r r r� � s
zBbox.y0c C s || j d< | �� d S �Nr� r r r r r r� � s
zBbox.x1c C s || j d< | �� d S �Nr� r r r r r r� � s
zBbox.y1c C s || j d< | �� d S �Nr r r r r r r� � s
zBbox.p0c C s || j d< | �� d S r0 r r r r r r� � s
zBbox.p1c C s || j d d �df< | �� d S r r �r �intervalr r r r� � s zBbox.intervalxc C s || j d d �df< | �� d S r0 r r r r r r� � s zBbox.intervalyc C sN |\}}}}t �||g|| || ggt�}t �| j|k�rJ|| _| �� d S r
)rp r� r� ru r� r] )r r� r� r� r� r� rv r r r r� � s
z Bbox.boundsc C s | j S )a
The minimum positive value in both directions within the Bbox.
This is useful when dealing with logarithmic scales and other scales
where negative bounds result in floating point errors, and will be used
as the minimum extent instead of *p0*.
�r� r% r r r r� � s z Bbox.minposc C s || j d d �< d S r
r r r r r r� � s c C s
| j d S )a#
The minimum positive value in the *x*-direction within the Bbox.
This is useful when dealing with logarithmic scales and other scales
where negative bounds result in floating point errors, and will be used
as the minimum *x*-extent instead of *x0*.
r r r% r r r �minposx� s z Bbox.minposxc C s || j d< d S r r r r r r r s c C s
| j d S )a#
The minimum positive value in the *y*-direction within the Bbox.
This is useful when dealing with logarithmic scales and other scales
where negative bounds result in floating point errors, and will be used
as the minimum *y*-extent instead of *y0*.
r r r% r r r �minposy
s z Bbox.minposyc C s || j d< d S r0 r r r r r r s c C s d| _ | jS )zn
Get the points of the bounding box as an array of the form
``[[x0, y0], [x1, y1]]``.
r )r; r� r% r r r ry s zBbox.get_pointsc C s" t �| j|k�r || _| �� dS )z�
Set the points of the bounding box directly from an array of the form
``[[x0, y0], [x1, y1]]``. No error checking is performed, as this
method is mainly for internal use.
N)rp ru r� r] r� r r r �
set_points! s zBbox.set_pointsc C s* t �| j|�� k�r&|�� | _| �� dS )zS
Set this bounding box from the "frozen" bounds of another `Bbox`.
N)rp ru r� ry r] �r rQ r r r �set+ s
zBbox.setc C s | � � p| �� S )z/Return whether the bbox has changed since init.)�mutatedx�mutatedyr% r r r �mutated3 s z Bbox.mutatedc C s( | j d | jd kp&| j d | jd kS )z4Return whether the x-limits have changed since init.r} r� �r� r� r% r r r r# 7 s �z
Bbox.mutatedxc C s( | j d | jd kp&| j d | jd kS )z4Return whether the y-limits have changed since init.r r� r& r% r r r r$ < s �z
Bbox.mutatedy)NTT)N)N)NTT),r" re rf rg r> rm r� r] rd r� r� r r r r r? r r� r r r r� ro r~ �setterr� r� r� r� r� r� r� r� r� r� r r ry r r" r% r# r$ rn r r rT r rx � sv P
"
rx c sR e Zd ZdZ� fdd�Zedd�Zdd� Zer:eZ dd� Zd d
� Z
d d � Z � Z S )
�TransformedBboxz�
A `Bbox` that is automatically transformed by a given
transform. When either the child bounding box or transform
changes, the bounds of this bbox will update accordingly.
c sl t jt|d� t jt|d� |jdks0|jdkr8td��t� jf i |�� || _ || _
| � ||� d| _ dS )ze
Parameters
----------
bbox : `Bbox`
transform : `Transform`
�r� �r� r4 z8The input and output dimensions of 'transform' must be 2N)
r �check_isinstancero � Transform�
input_dims� output_dimsr� rM r> �_bbox�
_transformrP r� )r r� r� r( rT r r r> I s � zTransformedBbox.__init__r/ r0 c C s$ | j �r | j�� }| j�|d |d g|d |d g|d |d g|d |d gg�}tj�|d�}t|d d �df �t |d d �df �f}|d |d kr�|d d d� }t|d d �df �t |d d �df �f}|d |d kr�|d d d� }t�
|d |d g|d |d gg�| _ d| _ | j S ) Nr} r r� r� � r r� r ) r; r/ ry r0 r� rp rq Zfilledr� r� r� r� )r r� rv �xsZysr r r ry ^ s,
��((�zTransformedBbox.get_pointsc C s | � � }| �|� |S r
�� _get_pointsrw r� r r r ry s
c C s | j j| j�� �||f�� S r
)r/ r� r0 �invertedr� r� r r r r� � s zTransformedBbox.containsc C s | j j| j�� �||f�� S r
)r/ r� r0 r5 r� r� r r r r� � s z TransformedBbox.fully_contains)
r" re rf rg r> r- r? ry rm r4 r� r� rn r r rT r r( B s
r( c s� e Zd ZdZd� fdd� Zedd�Zdd� Zer<eZ d d� Ze
d
d � �Z e j d d � �Z e
d
d� �Z
e
j dd� �Z
e
dd� �Zej dd� �Ze
dd� �Zej dd� �Z� ZS )� LockableBboxz�
A `Bbox` where some elements may be locked at certain values.
When the child bounding box changes, the bounds of this bbox will update
accordingly with the exception of the locked elements.
Nc sn t jt|d� t� jf i |�� || _| �|� d| _||||g}dd� |D �}tj j
|t |d�� d�| _
dS )a�
Parameters
----------
bbox : `Bbox`
The child bounding box to wrap.
x0 : float or None
The locked value for x0, or None to leave unlocked.
y0 : float or None
The locked value for y0, or None to leave unlocked.
x1 : float or None
The locked value for x1, or None to leave unlocked.
y1 : float or None
The locked value for y1, or None to leave unlocked.
r) Nc S s g | ] }|d u �qS r
r )r rS r r r r� � r z)LockableBbox.__init__.<locals>.<listcomp>��maskr� )r r+ ro rM r> r/ rP r� rp rq r� r� r �_locked_points) r r� r~ r� r� r� r( �fpr8 rT r r r> � s
zLockableBbox.__init__r/ r9 c C s2 | j r,| j�� }t�| jj|| j�| _d| _ | jS r )r; r/ ry rp �wherer9 r8 r� r� r r r ry � s
�zLockableBbox.get_pointsc C s | � � }| �|� |S r
r3 r� r r r ry � s
c C s | j jd rdS | j d S dS )zB
float or None: The value used for the locked x0.
r} N�r9 r8 r% r r r � locked_x0� s zLockableBbox.locked_x0c C s( |d u | j jd< || j jd< | �� d S r �r9 r8 �datar] )r r~ r r r r= � s c C s | j jd rdS | j d S dS )zB
float or None: The value used for the locked y0.
r Nr< r% r r r � locked_y0� s zLockableBbox.locked_y0c C s( |d u | j jd< || j jd< | �� d S r r> )r r� r r r r@ � s c C s | j jd rdS | j d S dS )zB
float or None: The value used for the locked x1.
r� Nr< r% r r r � locked_x1� s zLockableBbox.locked_x1c C s( |d u | j jd< || j jd< | �� d S r r> )r r� r r r rA � s c C s | j jd rdS | j d S dS )zB
float or None: The value used for the locked y1.
r� Nr< r% r r r � locked_y1� s zLockableBbox.locked_y1c C s( |d u | j jd< || j jd< | �� d S r r> )r r� r r r rB � s )NNNN)r" re rf rg r> r- r? ry rm r4 r� r= r' r@ rA rB rn r r rT r r6 � s.
r6 c @ s� e Zd ZdZdZdZdZdZdd� Zdd� Z dd � Z
e d
d � �Z d d
� Z
dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd-d)d*�Zd+d,� Z dS ).r, a�
The base class of all `TransformNode` instances that
actually perform a transformation.
All non-affine transformations should be subclasses of this class.
New affine transformations should be subclasses of `Affine2D`.
Subclasses of this class should override the following members (at
minimum):
- :attr:`input_dims`
- :attr:`output_dims`
- :meth:`transform`
- :meth:`inverted` (if an inverse exists)
The following attributes may be overridden if the default is unsuitable:
- :attr:`is_separable` (defaults to True for 1D -> 1D transforms, False
otherwise)
- :attr:`has_inverse` (defaults to True if :meth:`inverted` is overridden,
False otherwise)
If the transform needs to do something non-standard with
`matplotlib.path.Path` objects, such as adding curves
where there were once line segments, it should override:
- :meth:`transform_path`
NFc C sr t dd� | jD ��dkr:| j| j kr0dkr:n nd| _t dd� | jD ��dkrnt| d�rn| jtjurnd| _d S )Nc s s | ]}d t |�v V qdS )� is_separableN�rN �r ra r r r r ; r z.Transform.__init_subclass__.<locals>.<genexpr>r Tc s s | ]}d t |�v V qdS )� has_inverseNrD rE r r r r A r r5 ) r� �__mro__r- r. rC �hasattrr5 r, rF r1 r r r �__init_subclass__6 s ��
�
�zTransform.__init_subclass__c C s t |t�rt| |�S tS )z�
Compose two transforms together so that *self* is followed by *other*.
``A + B`` returns a transform ``C`` so that
``C.transform(x) == B.transform(A.transform(x))``.
)r r, �composite_transform_factory�NotImplementedr! r r r �__add__F s � �zTransform.__add__c c s t � | fV dS )a�
Return an iterator breaking down this transform stack from left to
right recursively. If self == ((A, N), A) then the result will be an
iterator which yields I : ((A, N), A), followed by A : (N, A),
followed by (A, N) : (A), but not ((A, N), A) : I.
This is equivalent to flattening the stack then yielding
``flat_stack[:i], flat_stack[i:]`` where i=0..(n-1).
N��IdentityTransformr% r r r � _iter_break_from_left_to_rightU s
z(Transform._iter_break_from_left_to_rightc C s dS )a
Return the number of transforms which have been chained
together to form this Transform instance.
.. note::
For the special case of a Composite transform, the maximum depth
of the two is returned.
r r r% r r r �deptha s zTransform.depthc C s4 | j |j k rdS | �� D ]\}}||kr dS qdS )aQ
Return whether the given transform is a sub-tree of this transform.
This routine uses transform equality to identify sub-trees, therefore
in many situations it is object id which will be used.
For the case where the given transform represents the whole
of this transform, returns True.
FT)rP rO )r rQ rG �sub_treer r r �contains_brancho s
zTransform.contains_branchc C s" | j dkrtd��| �|�fd S )aU
Return whether the given branch is a sub-tree of this transform on
each separate dimension.
A common use for this method is to identify if a transform is a blended
transform containing an Axes' data transform. e.g.::
x_isdata, y_isdata = trans.contains_branch_seperately(ax.transData)
r4 �Lcontains_branch_seperately only supports transforms with 2 output dimensions)r. r� rR �r Zother_transformr r r �contains_branch_seperately� s
z$Transform.contains_branch_seperatelyc C s� t |t�stS | �� D ]\}}||kr| S q|�� D ]*\}}|| kr8|jsVtd��|�� S q8|jrv| |�� S td��dS )a�
Compose *self* with the inverse of *other*, cancelling identical terms
if any::
# In general:
A - B == A + B.inverted()
# (but see note regarding frozen transforms below).
# If A "ends with" B (i.e. A == A' + B for some A') we can cancel
# out B:
(A' + B) - B == A'
# Likewise, if B "starts with" A (B = A + B'), we can cancel out A:
A - (A + B') == B'.inverted() == B'^-1
Cancellation (rather than naively returning ``A + B.inverted()``) is
important for multiple reasons:
- It avoids floating-point inaccuracies when computing the inverse of
B: ``B - B`` is guaranteed to cancel out exactly (resulting in the
identity transform), whereas ``B + B.inverted()`` may differ by a
small epsilon.
- ``B.inverted()`` always returns a frozen transform: if one computes
``A + B + B.inverted()`` and later mutates ``B``, then
``B.inverted()`` won't be updated and the last two terms won't cancel
out anymore; on the other hand, ``A + B - B`` will always be equal to
``A`` even if ``B`` is mutated.
zQThe shortcut cannot be computed since 'other' includes a non-invertible componentzpIt is not possible to compute transA - transB since transB cannot be inverted and there is no shortcut possible.N)r r, rK rO rF r� r5 )r rQ � remainderrQ r r r �__sub__� s
� zTransform.__sub__c O s | � � �� S )z9Array interface to get at this Transform's affine matrix.��
get_affine�
get_matrixr{ r r r r| � s zTransform.__array__c C s� t �|�}|j}|�d| jf�}| �| �|��}|dkrPt j�|�rHJ �|d S |dkrb|�d�S |dkrn|S t dj
| jd���dS ) a�
Apply this transformation on the given array of *values*.
Parameters
----------
values : array-like
The input values as an array of length :attr:`input_dims` or
shape (N, :attr:`input_dims`).
Returns
-------
array
The output values as an array of length :attr:`output_dims` or
shape (N, :attr:`output_dims`), depending on the input.
r� r r} r r4 z5Input values must have shape (N, {dims}) or ({dims},))�dimsN) rp �
asanyarray�ndimr r- �transform_affine�transform_non_affinerq Z is_maskedr� r )r r` r] �resr r r r� � s
��zTransform.transformc C s | � � �|�S )a�
Apply only the affine part of this transformation on the
given array of values.
``transform(values)`` is always equivalent to
``transform_affine(transform_non_affine(values))``.
In non-affine transformations, this is generally a no-op. In
affine transformations, this is equivalent to
``transform(values)``.
Parameters
----------
values : array
The input values as an array of length :attr:`input_dims` or
shape (N, :attr:`input_dims`).
Returns
-------
array
The output values as an array of length :attr:`output_dims` or
shape (N, :attr:`output_dims`), depending on the input.
�rY r� �r r` r r r r^ � s zTransform.transform_affinec C s |S )a�
Apply only the non-affine part of this transformation.
``transform(values)`` is always equivalent to
``transform_affine(transform_non_affine(values))``.
In non-affine transformations, this is generally equivalent to
``transform(values)``. In affine transformations, this is
always a no-op.
Parameters
----------
values : array
The input values as an array of length :attr:`input_dims` or
shape (N, :attr:`input_dims`).
Returns
-------
array
The output values as an array of length :attr:`output_dims` or
shape (N, :attr:`output_dims`), depending on the input.
r rb r r r r_ s z Transform.transform_non_affinec C s t | �|�� ��S )z�
Transform the given bounding box.
For smarter transforms including caching (a common requirement in
Matplotlib), see `TransformedBbox`.
)rx r� ry )r r� r r r �transform_bbox" s zTransform.transform_bboxc C s t � S )z&Get the affine part of this transform.rM r% r r r rY + s zTransform.get_affinec C s | � � �� S )z5Get the matrix for the affine part of this transform.rX r% r r r rZ / s zTransform.get_matrixc C s t |�| jkrtd��| �|�S )a�
Return a transformed point.
This function is only kept for backcompatibility; the more general
`.transform` method is capable of transforming both a list of points
and a single point.
The point is given as a sequence of length :attr:`input_dims`.
The transformed point is returned as a sequence of length
:attr:`output_dims`.
z/The length of 'point' must be 'self.input_dims')r� r- r� r� )r �pointr r r �transform_point3 s zTransform.transform_pointc C s | � | �|��S )z�
Apply the transform to `.Path` *path*, returning a new `.Path`.
In some cases, this transform may insert curves into the path
that began as line segments.
)�transform_path_affine�transform_path_non_affine�r r
r r r �transform_pathC s zTransform.transform_pathc C s | � � �|�S )z�
Apply the affine part of this transform to `.Path` *path*, returning a
new `.Path`.
``transform_path(path)`` is equivalent to
``transform_path_affine(transform_path_non_affine(values))``.
)rY rf rh r r r rf L s z Transform.transform_path_affinec C s | � |j�}t�||j|�S )z�
Apply the non-affine part of this transform to `.Path` *path*,
returning a new `.Path`.
``transform_path(path)`` is equivalent to
``transform_path_affine(transform_path_non_affine(values))``.
)r_ r� r �_fast_from_codes_and_verts�codes)r r
r r r r rg V s z#Transform.transform_path_non_affine��h㈵��>c
C s� | j dks| jdkr td��t�|�}t�|�}tjd|d� tjd|d� t|�t|�krdtd��|srt� |�}||t�
t� |�t� |�g� }| �
|�}| �
|�}|| }t�|dd�d f |dd�d
f �} |s�t�| �} | S ) a
Transform a set of angles anchored at specific locations.
Parameters
----------
angles : (N,) array-like
The angles to transform.
pts : (N, 2) array-like
The points where the angles are anchored.
radians : bool, default: False
Whether *angles* are radians or degrees.
pushoff : float
For each point in *pts* and angle in *angles*, the transformed
angle is computed by transforming a segment of length *pushoff*
starting at that point and making that angle relative to the
horizontal axis, and measuring the angle between the horizontal
axis and the transformed segment.
Returns
-------
(N,) array
r4 zOnly defined in 2Dr3 )r� r
)�anglesz'There must be as many 'angles' as 'pts'Nr r )r- r. r� rp rt r Z check_shaper� r� Zdeg2radr �cos�sinr� Zarctan2Zrad2deg)
r rm r� r� ZpushoffZpts2ZtptsZtpts2�dr� r r r �transform_anglesa s(
�
$
zTransform.transform_anglesc C s
t � �dS )a5
Return the corresponding inverse transformation.
It holds ``x == self.inverted().transform(self.transform(x))``.
The return value of this method should be treated as
temporary. An update to *self* does not cause a corresponding
update to its inverted copy.
Nr� r% r r r r5 � s
zTransform.inverted)Frl ) r" re rf rg r- r. rC rF rI rL rO r� rP rR rU rW r| r� r^ r_ rc rY rZ re ri rf rg rq r5 r r r r r, s4
2%
1r, c s� e Zd ZdZdZ� fdd�Zdd� Zed�Zdd � Z d
d � Z
e d d
� �Z e dd
� �Z
e dd
� �Ze dd
� �Ze dd
� �Z� ZS )�TransformWrappera�
A helper class that holds a single child transform and acts
equivalently to it.
This is useful if a node of the transform tree must be replaced at
run time with a transform of a different type. This class allows
that replacement to correctly trigger invalidation.
`TransformWrapper` instances must have the same input and output dimensions
during their entire lifetime, so the child transform may only be replaced
with another child transform of the same dimensions.
Tc s& t jt|d� t� �� | �|� dS )zn
*child*: A `Transform` instance. This child may later
be replaced with :meth:`set`.
)rc N)r r+ r, rM r> r" )r rc rT r r r> � s
zTransformWrapper.__init__c C s | j �|�S r
)�_child�__eq__r! r r r rt � s zTransformWrapper.__eq__rs c C s
| j �� S r
)rs rd r% r r r rd � s zTransformWrapper.frozenc C s� t | d�r^| �� |j|jf}| jj| jjf}||krJtd|� d|� ���| jj�t| �d� || _| � |� |j
| _
|j | _ |j | _ |j
| _
|j| _|j| _|j| _|j| _|j| _d| _| �� d| _dS )z�
Replace the current child of this transform with another one.
The new child must have the same number of input and output
dimensions as the current child.
rs z+The input and output dims of the new child z% do not match those of current child Nr )rH r] r- r. rs r� r9 rH rO rP r� r^ r_ ri rf rg rY r5 rZ r; )r rc Znew_dimsZold_dimsr r r r" � s2
��
zTransformWrapper.setc C s | j jS r
)rs r- r% r r r r) � r zTransformWrapper.<lambda>c C s | j jS r
)rs r. r% r r r r) � r c C s | j jS r
)rs r[ r% r r r r) � r c C s | j jS r
)rs rC r% r r r r) � r c C s | j jS r
)rs rF r% r r r r) � r )r" re rf rg r^ r> rt r- r? rd r" r� r- r. r[ rC rF rn r r rT r rr � s
% rr c sz e Zd ZdZdZ� fdd�Zdd� Zdd� Zd d
� Zd d � Z e
� d
dd�dd� �Z dd� Z
dd� Zdd� Zdd� Z� ZS )�
AffineBasezS
The base class of all affine transformations of any number of dimensions.
Tc s t � j|i |�� d | _d S r
)rM r> � _invertedr{ rT r r r> � s zAffineBase.__init__c O s | � � S r
�rZ r{ r r r r| � s zAffineBase.__array__c C s. t |dd�r*t|d�r*| �� |�� k�� S tS )Nr[ FrZ )r rH rZ r� rK r! r r r rt � s zAffineBase.__eq__c C s
| � |�S r
)r^ rb r r r r� s zAffineBase.transformc C s t d��d S )Nz.Affine subclasses should override this method.r� rb r r r r^ s zAffineBase.transform_affiner/ rv r` c C s |S r
r rb r r r r_ s z AffineBase.transform_non_affinec C s
| � |�S r
)rf rh r r r ri s zAffineBase.transform_pathc C s t | �|j�|j|j�S r
)r r^ r� rk Z_interpolation_stepsrh r r r rf s �z AffineBase.transform_path_affinec C s |S r
r rh r r r rg s z$AffineBase.transform_path_non_affinec C s | S r
r r% r r r rY s zAffineBase.get_affine)r" re rf rg r[ r> r| rt r� r^ r r� r_ ri rf rg rY rn r r rT r ru � s
ru c @ sp e Zd ZdZdZdZdd� Zedd� �Zdd� Z e
� d d
d �d d
� �Z e
rde Ze
� d d
d �dd
� �Z dd� ZdS )� Affine2DBasea�
The base class of all 2D affine transformations.
2D affine transformations are performed using a 3x3 numpy array::
a c e
b d f
0 0 1
This class provides the read-only interface. For a mutable 2D
affine transformation, use `Affine2D`.
Subclasses of this class will generally only need to override a
constructor and `~.Transform.get_matrix` that generates a custom 3x3 matrix.
r4 c C s t | �� �� �S r
)r� rZ rL r% r r r rd 3 s zAffine2DBase.frozenc C s( | � � }|d |d ko"dkS S )Nr r� r1 rw �r �mtxr r r rC 7 s zAffine2DBase.is_separablec C s" | � � }t|dd� �dd�j�S )zU
Return the values of the matrix as an ``(a, b, c, d, e, f)`` tuple.
Nr4 r r )rZ �tupleZswapaxesZflatry r r r � to_values< s zAffine2DBase.to_valuesr/ rv r` c C sD | � � }t|tjj�r:t|j|�}tjj|tj�|�d�S t||�S )Nr7 )rZ r rp rq rr r r? Zgetmask)r r` rz Ztpointsr r r r^ C s
z Affine2DBase.transform_affinec C s, t |tj�s"t�dt|�� d�� | �|�S )NzA non-numpy array of type zE was passed in for transformation, which results in poor performance.)r rp Zndarrayr rs r! �_transform_affinerb r r r r^ N s
�c C sJ | j d u s| jrD| �� }d }| jr,d| j }tt|�|d�| _ d| _| j S )Nz(%s)-1)r= r )rv r; rZ r< r� r )r rz r= r r r r5 Z s
zAffine2DBase.invertedN)r" re rf rg r- r. rd r� rC r| r r� r^ rm r} r5 r r r r rx s
rx c s� e Zd ZdZd"� fdd� Zed�Zdd� Zedd � �Z d
d � Z
d d
� Z dd� Z dd� Z
dd� Zdd� Zdd� Zdd� Zdd� Zd#d d �Zd d � Zd d!� Z� ZS )$r� z-
A mutable 2D affine transformation.
Nc s4 t � jf i |�� |du r tj}|�� | _d| _dS )z�
Initialize an Affine transform from a 3x3 numpy float array::
a c e
b d f
0 0 1
If *matrix* is None, initialize with the identity transform.
Nr )rM r> rN �_mtxrL r; )r Zmatrixr( rT r r r> k s
zAffine2D.__init__r~ c C sh | j t�t�| j ��k�� r$| �� S | j d | j d krVd| j d � d| j d � d�S d| j d � d�S )Nr} r� zAffine2D().scale(z, r )r~ rp Zdiagru � _base_strr% r r r r? ~ s �
� �zAffine2D.__str__c C s( t t�| |||||dddg t��d��S )z�
Create a new Affine2D instance from the given values::
a c e
b d f
0 0 1
.
r1 r� )r5 r5 )r� rp r� r� r )r� r� r� rp �e�fr r r � from_values� s "�zAffine2D.from_valuesc C s | j rd| _d| _ | jS )z�
Get the underlying transformation matrix as a 3x3 array::
a c e
b d f
0 0 1
.
Nr )r; rv r~ r% r r r rZ � s
zAffine2D.get_matrixc C s || _ | �� dS )z�
Set the underlying transformation matrix from a 3x3 array::
a c e
b d f
0 0 1
.
N�r~ r] ry r r r �
set_matrix� s
zAffine2D.set_matrixc C s$ t jt|d� |�� | _| �� dS )zh
Set this transformation from the frozen copy of another
`Affine2DBase` object.
)rQ N)r r+ rx rZ r~ r] r! r r r r" � s
z Affine2D.setc C s t j�� | _| �� | S )zH
Reset the underlying matrix to the identity transform.
)rN r~ rL r] r% r r r �clear� s zAffine2D.clearc C s� t �|�}t �|�}| j}|�� \\}}}\}} }
} || || |d< || || |d< || ||
|d< || || |d< || || |d< || ||
|d< | �� | S )z�
Add a rotation (in radians) to this transform in place.
Returns *self*, so this method can easily be chained with more
calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
and :meth:`scale`.
r} r �r r4 r� r� �r r4 )�mathrn ro r~ �tolistr] ) r �thetar� r� rz �xxr r~ �yx�yyr� rG r r r r� � s
zAffine2D.rotatec C s | � t�|��S )z�
Add a rotation (in degrees) to this transform in place.
Returns *self*, so this method can easily be chained with more
calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
and :meth:`scale`.
)r� r� r� )r �degreesr r r �
rotate_deg� s zAffine2D.rotate_degc C s | � | | ��|�� ||�S )z�
Add a rotation (in radians) around the point (x, y) in place.
Returns *self*, so this method can easily be chained with more
calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
and :meth:`scale`.
)� translater� )r r r� r� r r r �
rotate_around� s zAffine2D.rotate_aroundc C s0 t |�t |� }}| �| | ��|��||�S )z�
Add a rotation (in degrees) around the point (x, y) in place.
Returns *self*, so this method can easily be chained with more
calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
and :meth:`scale`.
)r� r� r� )r r r� r� r r r �rotate_deg_around� s zAffine2D.rotate_deg_aroundc C s0 | j d |7 < | j d |7 < | �� | S )z�
Add a translation in place.
Returns *self*, so this method can easily be chained with more
calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
and :meth:`scale`.
r� r� r� r� r r r r� � s zAffine2D.translatec C s� |du r |}| j d |9 < | j d |9 < | j d |9 < | j d |9 < | j d |9 < | j d |9 < | �� | S )a2
Add a scale in place.
If *sy* is None, the same scale is applied in both the *x*- and
*y*-directions.
Returns *self*, so this method can easily be chained with more
calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
and :meth:`scale`.
Nr} r r� r� r� r� r� )r ZsxZsyr r r �scale s zAffine2D.scalec
C s� t �|�}t �|�}| j}|�� \\}}}\} }
} } |d || 7 < |d ||
7 < |d || 7 < |d || 7 < |d || 7 < |d || 7 < | �� | S )aC
Add a skew in place.
*xShear* and *yShear* are the shear angles along the *x*- and
*y*-axes, respectively, in radians.
Returns *self*, so this method can easily be chained with more
calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
and :meth:`scale`.
r} r r� r� r� r� )r� �tanr~ r� r] )
r �xShear�yShear�rxZryrz r� r r~ r� r� r� rG r r r �skew s
z
Affine2D.skewc C s | � t�|�t�|��S )aC
Add a skew in place.
*xShear* and *yShear* are the shear angles along the *x*- and
*y*-axes, respectively, in degrees.
Returns *self*, so this method can easily be chained with more
calls to :meth:`rotate`, :meth:`rotate_deg`, :meth:`translate`
and :meth:`scale`.
)r� r� r� )r r� r� r r r �skew_deg6 s zAffine2D.skew_deg)N)N)r" re rf rg r> r- r r? r� r� rZ r� r" r� r� r� r� r� r� r� r� r� rn r r rT r r� f s$
r� c @ s� e Zd ZdZe�d�Zdd� Ze� Z dd� Z
e � ddd �d
d � �Z
e � ddd �d d
� �Ze � ddd �dd� �Zdd� Zdd� Zdd� Zdd� Zdd� ZdS )rN zY
A special class that does one thing, the identity transform, in a
fast way.
r5 c C s | S r
r r% r r r rd K s zIdentityTransform.frozenc C s | j S r
)r~ r% r r r rZ Q s z IdentityTransform.get_matrixr/ rv r` c C s
t �|�S r
�rp r\ rb r r r r� U s zIdentityTransform.transformc C s
t �|�S r
r� rb r r r r^ Z s z"IdentityTransform.transform_affinec C s
t �|�S r
r� rb r r r r_ _ s z&IdentityTransform.transform_non_affinec C s |S r
r rh r r r ri d s z IdentityTransform.transform_pathc C s |S r
r rh r r r rf h s z'IdentityTransform.transform_path_affinec C s |S r
r rh r r r rg l s z+IdentityTransform.transform_path_non_affinec C s | S r
r r% r r r rY p s z IdentityTransform.get_affinec C s | S r
r r% r r r r5 t s zIdentityTransform.invertedN)r" re rf rg rp �identityr~ rd r- r? rZ r r� r� r^ r_ ri rf rg rY r5 r r r r rN D s
rN c @ s* e Zd ZdZdd� Zdd� Zedd�ZdS ) �
_BlendedMixinzCCommon methods for `BlendedGenericTransform` and `BlendedAffine2D`.c C sD t |ttf�r&| j|jko$| j|jkS | j| jkr<| j|kS tS d S r
)r �BlendedAffine2D�BlendedGenericTransform�_x�_yrK r! r r r rt | s
z_BlendedMixin.__eq__c C s | j �|�| j�|�fS r
)r� rR r� )r r� r r r rU � s
�z(_BlendedMixin.contains_branch_seperatelyr� r� N)r" re rf rg rt rU r- r? r r r r r� y s r� c @ s� e Zd ZdZdZdZdZdZdd� Ze dd� �Z
dd � Z e d
d � �Z e d d � �Z
d
d� Ze�ddd�dd� �Zdd� Zdd� ZdS )r� z�
A "blended" transform uses one transform for the *x*-direction, and
another transform for the *y*-direction.
This "generic" version can handle any given child transform in the
*x*- and *y*-directions.
r4 Tc K s4 t j| fi |�� || _|| _| �||� d| _dS )ak
Create a new "blended" transform using *x_transform* to transform the
*x*-axis and *y_transform* to transform the *y*-axis.
You will generally not call this constructor directly but use the
`blended_transform_factory` function instead, which can determine
automatically which kind of blended transform to create.
N)r, r> r� r� rP �_affine)r � x_transform� y_transformr( r r r r> � s
z BlendedGenericTransform.__init__c C s t | jj| jj�S r
)r� r� rP r� r% r r r rP � s z BlendedGenericTransform.depthc C s dS r7 r r! r r r rR � s z'BlendedGenericTransform.contains_branchc C s | j jo| jjS r
)r� r[ r� r% r r r r) � r z BlendedGenericTransform.<lambda>c C s | j jo| jjS r
)r� rF r� r% r r r r) � r c C s t | j�� | j�� �S r
)�blended_transform_factoryr� rd r� r% r r r rd � s z BlendedGenericTransform.frozenr/ rv r` c C s | j jr| jjr|S | j }| j}||kr<|jdkr<|�|�S |jdkrb|�|�d d �dd�f }n(|�|d d �df �}|�t|�df�}|jdkr�|�|�d d �dd �f }n(|�|d d �df �}|�t|�df�}t|tj j
�s�t|tj j
��rtj � ||fd�S t� ||fd�S d S )Nr4 r r ) r� r[ r� r- r_ r r� r rp rq rr Z concatenate)r r` r r� Zx_pointsZy_pointsr r r r_ � s&
�z,BlendedGenericTransform.transform_non_affinec C s t | j�� | j�� �S r
)r� r� r5 r� r% r r r r5 � s z BlendedGenericTransform.invertedc C sx | j s| jd u rr| j| jkr*| j�� | _nB| j�� �� }| j�� �� }t�|d |d g d�g�}t|�| _d| _ | jS �Nr r �r1 r1 r� ) r; r� r� r� rY rZ rp r� r� )r �x_mtx�y_mtxrz r r r rY � s
z"BlendedGenericTransform.get_affineN)r" re rf rg r- r. rC r^ r> r� rP rR r[ rF rd r r� r_ r5 rY r r r r r� � s$
�
r� c @ s$ e Zd ZdZdZdd� Zdd� ZdS )r� z�
A "blended" transform uses one transform for the *x*-direction, and
another transform for the *y*-direction.
This version is an optimization for the case where both child
transforms are of type `Affine2DBase`.
Tc K sj |j o
|j }|jo|j}|o |}|s,td��tj| fi |�� || _|| _| �||� t�| � d| _ dS )a�
Create a new "blended" transform using *x_transform* to transform the
*x*-axis and *y_transform* to transform the *y*-axis.
Both *x_transform* and *y_transform* must be 2D affine transforms.
You will generally not call this constructor directly but use the
`blended_transform_factory` function instead, which can determine
automatically which kind of blended transform to create.
zABoth *x_transform* and *y_transform* must be 2D affine transformsN)
r[ rC r� r, r> r� r� rP rx r~ )r r� r� r( r[ rC Z
is_correctr r r r> � s
zBlendedAffine2D.__init__c C sd | j r^| j| jkr | j�� | _n2| j�� }| j�� }t�|d |d g d�g�| _d | _d| _ | jS r� )r; r� r� rZ r~ rp r� rv )r r� r� r r r rZ s
zBlendedAffine2D.get_matrixN)r" re rf rg rC r> rZ r r r r r� � s r� c C s( t | t�r t |t�r t| |�S t| |�S )z�
Create a new "blended" transform using *x_transform* to transform
the *x*-axis and *y_transform* to transform the *y*-axis.
A faster version of the blended transform is returned for the case
where both child transforms are affine.
)r rx r� r� )r� r� r r r r� s
�
r� c s� e Zd ZdZdZ� fdd�Zdd� Z� fdd�Zd d
� Zd d � Z d
d� Z
e dd� �Z e dd� �Z
e dd� �Ze dd� �Zedd�Ze�ddd�dd� �Ze�ddd�dd � �Zd d � Zd d � Zd!d"� Z� ZS )#�CompositeGenericTransformz�
A composite transform formed by applying transform *a* then
transform *b*.
This "generic" version can handle any two arbitrary
transformations.
Tc sR |j |jkrtd��|j| _|j | _ t� jf i |�� || _|| _| �||� dS )a@
Create a new composite transform that is the result of
applying transform *a* then transform *b*.
You will generally not call this constructor directly but write ``a +
b`` instead, which will automatically choose the best kind of composite
transform instance to create.
�HThe output dimension of 'a' must be equal to the input dimensions of 'b'N)r. r- r� rM r> �_a�_brP �r r� r� r( rT r r r> 6 s z"CompositeGenericTransform.__init__c C s2 d| _ t| j�� | j�� �}t|t�s.|�� S |S r )r; rJ r� rd r� r r� )r rd r r r rd J s �
z CompositeGenericTransform.frozenc s* || j u r| jjstj}t� �||� d S r
)r� r� r[ r, r: rM rZ )r rX rY rT r r rZ S s z.CompositeGenericTransform._invalidate_internalc C s6 t |ttf�r.| |u p,| j|jko,| j|jkS dS d S r7 )r r� �CompositeAffine2Dr� r� r! r r r rt Z s
�z CompositeGenericTransform.__eq__c c sL | j �� D ]\}}||| j fV q
| j�� D ]\}}| j | |fV q.d S r
�r� rO r� �r �left�rightr r r rO a s z8CompositeGenericTransform._iter_break_from_left_to_rightc C s* | j dkrtd��| |kr dS | j�|�S )Nr4 rS )TT)r. r� r� rU rT r r r rU g s
z4CompositeGenericTransform.contains_branch_seperatelyc C s | j j| jj S r
�r� rP r� r% r r r r) p r z"CompositeGenericTransform.<lambda>c C s | j jo| jjS r
)r� r[ r� r% r r r r) q r c C s | j jo| jjS r
)r� rC r� r% r r r r) s r c C s | j jo| jjS r
)r� rF r� r% r r r r) u r r� r� r/ rv r` c C s | � � �|�S r
ra rb r r r r^ y s z*CompositeGenericTransform.transform_affinec C sH | j jr| jjr|S | j js0| jjr0| j �|�S | j�| j �|��S d S r
)r� r[ r� r_ r� rb r r r r_ ~ s
z.CompositeGenericTransform.transform_non_affinec C sH | j jr| jjr|S | j js0| jjr0| j �|�S | j�| j �|��S d S r
)r� r[ r� rg ri rh r r r rg � s
�z3CompositeGenericTransform.transform_path_non_affinec C s: | j js| j �� S tt�| j �� �� | j�� �� ��S d S r
)r� r[ rY r� rp �dotrZ r� r% r r r rY � s
�z$CompositeGenericTransform.get_affinec C s t | j�� | j�� �S r
)r� r� r5 r� r% r r r r5 � s �z"CompositeGenericTransform.inverted)r" re rf rg r^ r> rd rZ rt rO rU r� rP r[ rC rF r- r? r r� r^ r_ rg rY r5 rn r r rT r r� , s0 ��
r� c sF e Zd ZdZ� fdd�Zedd� �Zdd� Zedd �Z d
d � Z
� Z S ) r� z�
A composite transform formed by applying transform *a* then transform *b*.
This version is an optimization that handles the case where both *a*
and *b* are 2D affines.
c sl |j r |j std��|j|jkr(td��|j| _|j| _t� jf i |�� || _|| _| �||� d| _ dS )aJ
Create a new composite transform that is the result of
applying `Affine2DBase` *a* then `Affine2DBase` *b*.
You will generally not call this constructor directly but write ``a +
b`` instead, which will automatically choose the best kind of composite
transform instance to create.
z%'a' and 'b' must be affine transformsr� N)
r[ r� r. r- rM r> r� r� rP r~ r� rT r r r> � s zCompositeAffine2D.__init__c C s | j j| jj S r
r� r% r r r rP � s zCompositeAffine2D.depthc c sL | j �� D ]\}}||| j fV q
| j�� D ]\}}| j | |fV q.d S r
r� r� r r r rO � s z0CompositeAffine2D._iter_break_from_left_to_rightr� r� c C s2 | j r,t�| j�� | j�� �| _d | _d| _ | jS r )r; rp r� r� rZ r� r~ rv r% r r r rZ � s �z CompositeAffine2D.get_matrix) r" re rf rg r> r� rP rO r- r? rZ rn r r rT r r� � s
r� c C sD t | t�r|S t |t�r | S t | t�r:t |t�r:t| |�S t| |�S )av
Create a new composite transform that is the result of applying
transform a then transform b.
Shortcut versions of the blended transform are provided for the
case where both child transforms are affine, or one or the other
is the identity transform.
Composite transforms may also be created using the '+' operator,
e.g.::
c = a + b
)r rN r� r� r� )r� r� r r r rJ � s
rJ c s6 e Zd ZdZdZ� fdd�Zedd�Zdd� Z� Z S ) �
BboxTransformzP
`BboxTransform` linearly transforms points from one `Bbox` to another.
Tc sJ t jt||d� t� jf i |�� || _|| _| �||� d| _d| _ dS )zp
Create a new `BboxTransform` that linearly transforms
points from *boxin* to *boxout*.
)�boxin�boxoutN)
r r+ ro rM r> �_boxin�_boxoutrP r~ rv )r r� r� r( rT r r r> � s zBboxTransform.__init__r� r� c C s� | j r�| jj\}}}}| jj\}}}}|| } || }
trR| dksJ|
dkrRtd��t�| d| | | gd|
| |
| gg d�gt�| _ d | _
d| _ | j S )Nr z/Transforming from or to a singular bounding boxr1 r� ) r; r� r� r� rm r� rp r� r� r~ rv ) r �inl�inb�inw�inh�outl�outb�outw�outh�x_scale�y_scaler r r rZ
s$ ���zBboxTransform.get_matrix�
r" re rf rg rC r> r- r? rZ rn r r rT r r� � s
r� c s4 e Zd ZdZdZ� fdd�Zed�Zdd� Z� Z S )�BboxTransformToz�
`BboxTransformTo` is a transformation that linearly transforms points from
the unit bounding box to a given `Bbox`.
Tc s@ t jt|d� t� jf i |�� || _| �|� d| _d| _dS )z�
Create a new `BboxTransformTo` that linearly transforms
points from the unit bounding box to *boxout*.
)r� N) r r+ ro rM r> r� rP r~ rv )r r� r( rT r r r> "
s
zBboxTransformTo.__init__r� c C sh | j rb| jj\}}}}tr2|dks*|dkr2td��t�|d|gd||gg d�gt�| _d | _ d| _ | jS �Nr z(Transforming to a singular bounding box.r1 r� )
r; r� r� rm r� rp r� r� r~ rv )r r� r� r� r� r r r rZ 1
s ��zBboxTransformTo.get_matrixr� r r rT r r�
s
r� r6 c @ s e Zd ZdZdd� ZdS )�BboxTransformToMaxOnlyz�
`BboxTransformToMaxOnly` is a transformation that linearly transforms points from
the unit bounding box to a given `Bbox` with a fixed upper left of (0, 0).
c C sd | j r^| jj\}}tr.|dks&|dkr.td��t�|ddgd|dgg d�gt�| _d | _ d| _ | jS r� )
r; r� r� rm r� rp r� r� r~ rv )r r� r� r r r rZ F
s ��z!BboxTransformToMaxOnly.get_matrixN)r" re rf rg rZ r r r r r� @
s r� c s4 e Zd ZdZdZ� fdd�Zed�Zdd� Z� Z S )�BboxTransformFromzj
`BboxTransformFrom` linearly transforms points from a given `Bbox` to the
unit bounding box.
Tc s@ t jt|d� t� jf i |�� || _| �|� d | _d | _d S )N)r� ) r r+ ro rM r> r� rP r~ rv )r r� r( rT r r r> \
s
zBboxTransformFrom.__init__r� c C s� | j r~| jj\}}}}tr2|dks*|dkr2td��d| }d| }t�|d| | gd|| | gg d�gt�| _d | _ d| _ | jS )Nr z*Transforming from a singular bounding box.r� r1 r� )
r; r� r� rm r� rp r� r� r~ rv )r r� r� r� r� r� r� r r r rZ g
s ��z BboxTransformFrom.get_matrixr� r r rT r r� U
s
r� c s0 e Zd ZdZ� fdd�Zed�Zdd� Z� ZS )�ScaledTranslationz|
A transformation that translates by *xt* and *yt*, after *xt* and *yt*
have been transformed by *scale_trans*.
c s< t � jf i |�� ||f| _|| _| �|� d | _d | _d S r
)rM r> �_t� _scale_transrP r~ rv )r ZxtZytZ scale_transr( rT r r r> }
s
zScaledTranslation.__init__r� c C s@ | j r:tj�� | _| j�| j�| jd d�df< d| _ d | _| jS )Nr4 r )r; rN r~ rL r� r� r� rv r% r r r rZ �
s z ScaledTranslation.get_matrix� r" re rf rg r> r- r? rZ rn r r rT r r� x
s r� c s0 e Zd ZdZ� fdd�Zed�Zdd� Z� ZS )�AffineDeltaTransformav
A transform wrapper for transforming displacements between pairs of points.
This class is intended to be used to transform displacements ("position
deltas") between pairs of points (e.g., as the ``offset_transform``
of `.Collection`\s): given a transform ``t`` such that ``t =
AffineDeltaTransform(t) + offset``, ``AffineDeltaTransform``
satisfies ``AffineDeltaTransform(a - b) == AffineDeltaTransform(a) -
AffineDeltaTransform(b)``.
This is implemented by forcing the offset components of the transform
matrix to zero.
This class is experimental as of 3.3, and the API may change.
c s t � jf i |�� || _d S r
)rM r> �_base_transform)r r� r( rT r r r> �
s z AffineDeltaTransform.__init__r� c C s. | j r(| j�� �� | _d| jd d�df< | jS )Nr r4 r� )r; r� rZ rL r~ r% r r r rZ �
s z AffineDeltaTransform.get_matrixr� r r rT r r� �
s r� c sH e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Z � Z
S )�TransformedPathaa
A `TransformedPath` caches a non-affine transformed copy of the
`~.path.Path`. This cached copy is automatically updated when the
non-affine part of the transform changes.
.. note::
Paths are considered immutable by this class. Any update to the
path's vertices/codes will not trigger a transform recomputation.
c s> t jt|d� t� �� || _|| _| �|� d| _d| _ dS )zl
Parameters
----------
path : `~.path.Path`
transform : `Transform`
r* N)
r r+ r, rM r> �_pathr0 rP �_transformed_path�_transformed_points)r r
r� rT r r r> �
s
zTransformedPath.__init__c C sN | j | jks| jd u rD| j�| j�| _t�| j�| jj �d | j�| _
d| _ d S r ) r; r: r� r0 rg r� r rj r_ r� r� r% r r r � _revalidate�
s � ���zTransformedPath._revalidatec C s | � � | j| �� fS )a3
Return a copy of the child path, with the non-affine part of
the transform already applied, along with the affine part of
the path necessary to complete the transformation. Unlike
:meth:`get_transformed_path_and_affine`, no interpolation will
be performed.
)r� r� rY r% r r r �!get_transformed_points_and_affine�
s z1TransformedPath.get_transformed_points_and_affinec C s | � � | j| �� fS )z�
Return a copy of the child path, with the non-affine part of
the transform already applied, along with the affine part of
the path necessary to complete the transformation.
)r� r� rY r% r r r � get_transformed_path_and_affine�
s z/TransformedPath.get_transformed_path_and_affinec C s | � � | j�| j�S )zD
Return a fully-transformed copy of the child path.
)r� r0 rf r� r% r r r �get_fully_transformed_path�
s z*TransformedPath.get_fully_transformed_pathc C s
| j �� S r
)r0 rY r% r r r rY �
s zTransformedPath.get_affine) r" re rf rg r> r� r� r� r� rY rn r r rT r r� �
s
r� c s, e Zd ZdZ� fdd�Z� fdd�Z� ZS )�TransformedPatchPathz�
A `TransformedPatchPath` caches a non-affine transformed copy of the
`~.patches.Patch`. This cached copy is automatically updated when the
non-affine part of the transform or the patch changes.
c s t � �|�� |�� � || _dS )zQ
Parameters
----------
patch : `~.patches.Patch`
N)rM r> �get_pathZ
get_transform�_patch)r �patchrT r r r> �
s z TransformedPatchPath.__init__c s. | j �� }|| jkr || _d | _t� �� d S r
)r� r� r� r� rM r� )r Z
patch_pathrT r r r� s
z TransformedPatchPath._revalidate)r" re rf rg r> r� rn r r rT r r� �
s
r� ���MbP?�V瞯�<Tc C s� t �| �rt �|�s | |fS d}|| k r8|| } }d}tt| |g�\} }tt| �t|��}|d| t �t�j k r�| } |}nL|| || kr�|dkr�| dkr�| } |}n | |t| � 8 } ||t|� 7 }|r�|s�|| } }| |fS )a�
Modify the endpoints of a range as needed to avoid singularities.
Parameters
----------
vmin, vmax : float
The initial endpoints.
expander : float, default: 0.001
Fractional amount by which *vmin* and *vmax* are expanded if
the original interval is too small, based on *tiny*.
tiny : float, default: 1e-15
Threshold for the ratio of the interval to the maximum absolute
value of its endpoints. If the interval is smaller than
this, it will be expanded. This value should be around
1e-15 or larger; otherwise the interval will be approaching
the double precision resolution limit.
increasing : bool, default: True
If True, swap *vmin*, *vmax* if *vmin* > *vmax*.
Returns
-------
vmin, vmax : float
Endpoints, expanded and/or swapped if necessary.
If either input is inf or NaN, or if both inputs are 0 or very
close to zero, it returns -*expander*, *expander*.
FTg ��.Ar )rp �isfinite�mapr� r� �absZfinfo�tiny)ZvminZvmaxZexpanderr� Z
increasingZswappedZ maxabsvaluer r r � nonsingular s(
r� c C s2 | \}}||kr|| }}|| ko,|kS S )a:
Check, inclusively, whether an interval includes a given value.
Parameters
----------
interval : (float, float)
The endpoints of the interval.
val : float
Value to check is within interval.
Returns
-------
bool
Whether *val* is within the *interval*.
r �r rS r� r� r r r �interval_containsL s
r� 绽���|�=c C sF | \}}||kr|| }}|| | }|| | ko@|| kS S )a�
Check, inclusively, whether an interval includes a given value, with the
interval expanded by a small tolerance to admit floating point errors.
Parameters
----------
interval : (float, float)
The endpoints of the interval.
val : float
Value to check is within interval.
rtol : float, default: 1e-10
Relative tolerance slippage allowed outside of the interval.
For an interval ``[a, b]``, values
``a - rtol * (b - a) <= val <= b + rtol * (b - a)`` are considered
inside the interval.
Returns
-------
bool
Whether *val* is within the *interval* (with tolerance).
r )r rS Zrtolr� r� r r r �_interval_contains_closeb s
r� c C s8 | \}}|| k o|k n p6|| ko2|kS S )aB
Check, excluding endpoints, whether an interval includes a given value.
Parameters
----------
interval : (float, float)
The endpoints of the interval.
val : float
Value to check is within interval.
Returns
-------
bool
Whether *val* is within the *interval*.
r r� r r r �interval_contains_open s r� r1 �inchesc C sf t jg d�|d� |dkr,| t� �||� S |du r<td��|dkrT|d }|d }| t|||j� S )a
Return a new transform with an added offset.
Parameters
----------
trans : `Transform` subclass
Any transform, to which offset will be applied.
fig : `~matplotlib.figure.Figure`, default: None
Current figure. It can be None if *units* are 'dots'.
x, y : float, default: 0.0
The offset to apply.
units : {'inches', 'points', 'dots'}, default: 'inches'
Units of the offset.
Returns
-------
`Transform` subclass
Transform with applied offset.
)�dotsrv r� )�unitsr� Nz3For units of inches or points a fig kwarg is neededrv g R@)r Z
check_in_listr� r� r� r� Zdpi_scale_trans)ZtransZfigr r� r� r r r � offset_copy� s r� )r� r� T)r� )Nr1 r1 r� )7rg rL r* r, rI r� �numpyrp Z numpy.linalgr Z
matplotlibr Zmatplotlib._pathr r r r
r rm r- r. ro r� r� r� rx r( r6 r, rr ru rx r� rN r� r� r� r� r� r� rJ r� r� rh r� r� r� r� r� r� r� r� r� r� r� r r r r �<module> sn & S Ky N3F _5^5t5*&# G
: