File: //home/arjun/projects/env/lib/python3.10/site-packages/cairocffi/__pycache__/matrix.cpython-310.pyc
o
*weY � @ s, d Z ddlmZmZmZ G dd� de�ZdS )z�
cairocffi.matrix
~~~~~~~~~~~~~~~~
Transformation matrices.
:copyright: Copyright 2013-2019 by Simon Sapin
:license: BSD, see LICENSE for details.
� )�
_check_status�cairo�ffic @ s� e Zd ZdZd/dd�Zedd� �Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� ZeZdd� Zd0dd �Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zed)�Zed*�Zed+�Zed,�Zed-�Z ed.�Z [dS )1�Matrixa A 2D transformation matrix.
Matrices are used throughout cairo to convert between
different coordinate spaces.
A :class:`Matrix` holds an affine transformation,
such as a scale, rotation, shear, or a combination of these.
The transformation of a point (x,y) is given by::
x_new = xx * x + xy * y + x0
y_new = yx * x + yy * y + y0
The current transformation matrix of a :class:`Context`,
represented as a :class:`Matrix`,
defines the transformation from user-space coordinates
to device-space coordinates.
See :meth:`Context.get_matrix` and :meth:`Context.set_matrix`.
The default values produce an identity matrix.
Matrices can be compared with ``m1 == m2`` and ``m2 != m2``
as well as multiplied with ``m3 = m1 * m2``.
r � c C s( t �d�| _t�| j||||||� d S )Nzcairo_matrix_t *)r �new�_pointerr �cairo_matrix_init)�self�xx�yx�xy�yy�x0�y0� r �I/home/arjun/projects/env/lib/python3.10/site-packages/cairocffi/matrix.py�__init__' s zMatrix.__init__c C s | � }t �|j|� |S )a� Return a new :class:`Matrix` for a transformation
that rotates by ``radians``.
:type radians: float
:param radians:
Angle of rotation, in radians.
The direction of rotation is defined such that
positive angles rotate in the direction
from the positive X axis toward the positive Y axis.
With the default axis orientation of cairo,
positive angles rotate in a clockwise direction.
)r �cairo_matrix_init_rotater )�cls�radians�resultr r r � init_rotate+ s zMatrix.init_rotatec C s" | j }|j|j|j|j|j|jfS )uu Return all of the matrix’s components.
:returns: A ``(xx, yx, xy, yy, x0, y0)`` tuple of floats.
)r r r r
r r r )r
�ptrr r r �as_tuple> s zMatrix.as_tuplec C s t | �| �� � S )z!Return a new copy of this matrix.)�typer �r
r r r �copyG s z Matrix.copyc C s t | jd| �S )N)r r r
r r r ��getattrr )r
�indexr r r � __getitem__K s
�zMatrix.__getitem__c C s t | �� �S �N)�iterr r r r r �__iter__O s zMatrix.__iter__c C s | � � |� � kS r" �r �r
�otherr r r �__eq__R � z
Matrix.__eq__c C s | � � |� � kS r" r% r& r r r �__ne__U r) z
Matrix.__ne__c C s t | �}d|jf| �� S )Nz%s(%g, %g, %g, %g, %g, %g))r �__name__r )r
�class_r r r �__repr__X s �zMatrix.__repr__c C s t � }t�|j| j|j� |S )z�Multiply with another matrix
and return the result as a new :class:`Matrix` object.
Same as ``self * other``.
)r r �cairo_matrix_multiplyr )r
r' �resr r r �multiply] s
�zMatrix.multiplyc C s t �| j||� dS )a� Applies a translation by ``tx``, ``ty``
to the transformation in this matrix.
The effect of the new transformation is to
first translate the coordinates by ``tx`` and ``ty``,
then apply the original transformation to the coordinates.
.. note::
This changes the matrix in-place.
:param tx: Amount to translate in the X direction.
:param ty: Amount to translate in the Y direction.
:type tx: float
:type ty: float
N)r �cairo_matrix_translater )r
�tx�tyr r r � translatej s zMatrix.translateNc C s |du r|}t �| j||� dS )aM Applies scaling by ``sx``, ``sy``
to the transformation in this matrix.
The effect of the new transformation is to
first scale the coordinates by ``sx`` and ``sy``,
then apply the original transformation to the coordinates.
If ``sy`` is omitted, it is the same as ``sx``
so that scaling preserves aspect ratios.
.. note::
This changes the matrix in-place.
:param sx: Scale factor in the X direction.
:param sy: Scale factor in the Y direction.
:type sx: float
:type sy: float
N)r �cairo_matrix_scaler )r
�sx�syr r r �scale} s z Matrix.scalec C s t �| j|� dS )a� Applies a rotation by ``radians``
to the transformation in this matrix.
The effect of the new transformation is to
first rotate the coordinates by ``radians``,
then apply the original transformation to the coordinates.
.. note::
This changes the matrix in-place.
:type radians: float
:param radians:
Angle of rotation, in radians.
The direction of rotation is defined such that positive angles
rotate in the direction from the positive X axis
toward the positive Y axis.
With the default axis orientation of cairo,
positive angles rotate in a clockwise direction.
N)r �cairo_matrix_rotater )r
r r r r �rotate� s z
Matrix.rotatec C s t t�| j�� dS )au Changes matrix to be the inverse of its original value.
Not all transformation matrices have inverses;
if the matrix collapses points together (it is degenerate),
then it has no inverse and this function will fail.
.. note::
This changes the matrix in-place.
:raises: :exc:`CairoError` on degenerate matrices.
N)r r �cairo_matrix_invertr r r r r �invert� s z
Matrix.invertc C s | � � }|�� |S )z�Return the inverse of this matrix. See :meth:`invert`.
:raises: :exc:`CairoError` on degenerate matrices.
:returns: A new :class:`Matrix` object.
)r r< )r
�matrixr r r �inverted� s zMatrix.invertedc C �0 t �d||g�}t�| j|d |d � t|�S )z�Transforms the point ``(x, y)`` by this matrix.
:param x: X position.
:param y: Y position.
:type x: float
:type y: float
:returns: A ``(new_x, new_y)`` tuple of floats.
� double[2]r r )r r r � cairo_matrix_transform_pointr �tuple)r
�x�yr
r r r �transform_point� s
zMatrix.transform_pointc C r? )a] Transforms the distance vector ``(dx, dy)`` by this matrix.
This is similar to :meth:`transform_point`
except that the translation components of the transformation
are ignored.
The calculation of the returned vector is as follows::
dx2 = dx1 * xx + dy1 * xy
dy2 = dx1 * yx + dy1 * yy
Affine transformations are position invariant,
so the same vector always transforms to the same vector.
If ``(x1, y1)`` transforms to ``(x2, y2)``
then ``(x1 + dx1, y1 + dy1)`` will transform
to ``(x1 + dx2, y1 + dy2)`` for all values of ``x1`` and ``x2``.
:param dx: X component of a distance vector.
:param dy: Y component of a distance vector.
:type dx: float
:type dy: float
:returns: A ``(new_dx, new_dy)`` tuple of floats.
r@ r r )r r r � cairo_matrix_transform_distancer rB )r
�dx�dyr
r r r �transform_distance� s zMatrix.transform_distancec s t � fdd�� fdd�dd�S )Nc s t | j� �S r" r r ��namer r �<lambda>� s z,Matrix._component_property.<locals>.<lambda>c s t | j� |�S r" )�setattrr )r
�valuerJ r r rL � s z8Read-write attribute access to a single float component.)�doc)�propertyrJ r rJ r �_component_property� s
�zMatrix._component_propertyr r r
r r r )r r r r r r r" ) r+ �
__module__� __qualname__�__doc__r � classmethodr r r r! r$ r( r* r- r0 �__mul__r4 r8 r: r< r> rE rI rQ r r r
r r r r r r r r s:
r N)rT � r r r �objectr r r r r �<module> s