Warning: session_start(): Session cannot be started after headers have already been sent in /home/tvrreohg/public_html/manga.php on line 13
3
2j# @ s d Z ddlmZ ddddgZdZde Zde Zd d
ZG d d deZe Z dd dZ
dddZ e dkrdd
l
Z
dd
lZe
jej j d
S )a Affine 2D transformation matrix class.
The Transform class implements various transformation matrix operations,
both on the matrix itself, as well as on 2D coordinates.
Transform instances are effectively immutable: all methods that operate on the
transformation itself always return a new instance. This has as the
interesting side effect that Transform instances are hashable, ie. they can be
used as dictionary keys.
This module exports the following symbols:
Transform -- this is the main class
Identity -- Transform instance set to the identity transformation
Offset -- Convenience function that returns a translating transformation
Scale -- Convenience function that returns a scaling transformation
Examples:
>>> t = Transform(2, 0, 0, 3, 0, 0)
>>> t.transformPoint((100, 100))
(200, 300)
>>> t = Scale(2, 3)
>>> t.transformPoint((100, 100))
(200, 300)
>>> t.transformPoint((0, 0))
(0, 0)
>>> t = Offset(2, 3)
>>> t.transformPoint((100, 100))
(102, 103)
>>> t.transformPoint((0, 0))
(2, 3)
>>> t2 = t.scale(0.5)
>>> t2.transformPoint((100, 100))
(52.0, 53.0)
>>> import math
>>> t3 = t2.rotate(math.pi / 2)
>>> t3.transformPoint((0, 0))
(2.0, 3.0)
>>> t3.transformPoint((100, 100))
(-48.0, 53.0)
>>> t = Identity.scale(0.5).translate(100, 200).skew(0.1, 0.2)
>>> t.transformPoints([(0, 0), (1, 1), (100, 100)])
[(50.0, 100.0), (50.550167336042726, 100.60135501775433), (105.01673360427253, 160.13550177543362)]
>>>
)
NamedTuple TransformIdentityOffsetScalegV瞯< c C s0 t | tk rd} n| tkr d} n | tk r,d} | S )Nr r )abs_EPSILON _ONE_EPSILON_MINUS_ONE_EPSILON)v r =/tmp/pip-build-_d5lkt3n/fonttools/fontTools/misc/transform.py _normSinCos; s r c @ s e Zd ZU dZdZedZedZedZedZ e dZ
e
dd Z dd Z dd Z
d
d Zd!d d
Zd"ddZdd Zd#ddZdd Zdd Zdd Zdd Zd d Zd d ZdS )$r aw 2x2 transformation matrix plus offset, a.k.a. Affine transform.
Transform instances are immutable: all transforming methods, eg.
rotate(), return a new Transform instance.
Examples:
>>> t = Transform()
>>> t
>>> t.scale(2)
>>> t.scale(2.5, 5.5)
>>>
>>> t.scale(2, 3).transformPoint((100, 100))
(200, 300)
Transform's constructor takes six arguments, all of which are
optional, and can be used as keyword arguments:
>>> Transform(12)
>>> Transform(dx=12)
>>> Transform(yx=12)
Transform instances also behave like sequences of length 6:
>>> len(Identity)
6
>>> list(Identity)
[1, 0, 0, 1, 0, 0]
>>> tuple(Identity)
(1, 0, 0, 1, 0, 0)
Transform instances are comparable:
>>> t1 = Identity.scale(2, 3).translate(4, 6)
>>> t2 = Identity.translate(8, 18).scale(2, 3)
>>> t1 == t2
1
But beware of floating point rounding errors:
>>> t1 = Identity.scale(0.2, 0.3).translate(0.4, 0.6)
>>> t2 = Identity.translate(0.08, 0.18).scale(0.2, 0.3)
>>> t1
>>> t2
>>> t1 == t2
0
Transform instances are hashable, meaning you can use them as
keys in dictionaries:
>>> d = {Scale(12, 13): None}
>>> d
{: None}
But again, beware of floating point rounding errors:
>>> t1 = Identity.scale(0.2, 0.3).translate(0.4, 0.6)
>>> t2 = Identity.translate(0.08, 0.18).scale(0.2, 0.3)
>>> t1
>>> t2
>>> d = {t1: None}
>>> d
{: None}
>>> d[t2]
Traceback (most recent call last):
File "", line 1, in ?
KeyError:
r r c
C s@ |\}}| \}}}}}} || || | || || | fS )zTransform a point.
Example:
>>> t = Transform()
>>> t = t.scale(2.5, 5.5)
>>> t.transformPoint((100, 100))
(250.0, 550.0)
r )
selfpxyxxxyyxyydxdyr r r transformPoint s zTransform.transformPointc s, | \ fdd|D S )zTransform a list of points.
Example:
>>> t = Scale(2, 3)
>>> t.transformPoints([(0, 0), (0, 100), (100, 100), (100, 0)])
[(0, 0), (0, 300), (200, 300), (200, 0)]
>>>
c s8 g | ]0\}}| | | | fqS r r ).0r r )r r r r r r r r
s z-Transform.transformPoints..r )r Zpointsr )r r r r r r r transformPoints s zTransform.transformPointsc C s< |\}}| dd \}}}}|| || || || fS )zTransform an (dx, dy) vector, treating translation as zero.
Example:
>>> t = Transform(2, 0, 0, 2, 10, 20)
>>> t.transformVector((3, -4))
(6, -8)
>>>
N r )r r
r r r r r r r r r transformVector s zTransform.transformVectorc s, | dd \ fdd|D S )zTransform a list of (dx, dy) vector, treating translation as zero.
Example:
>>> t = Transform(2, 0, 0, 2, 10, 20)
>>> t.transformVectors([(3, -4), (5, -6)])
[(6, -8), (10, -12)]
>>>
Nr c s0 g | ](\}} | | | | fqS r r )r r r )r r r r r r r s z.Transform.transformVectors..r )r Zvectorsr )r r r r r transformVectors s zTransform.transformVectorsc C s | j dddd||fS )zReturn a new transformation, translated (offset) by x, y.
Example:
>>> t = Transform()
>>> t.translate(20, 30)
>>>
r r ) transform)r r r r r r translate s zTransform.translateNc C s" |dkr |}| j |dd|ddfS )a
Return a new transformation, scaled by x, y. The 'y' argument
may be None, which implies to use the x value for y as well.
Example:
>>> t = Transform()
>>> t.scale(5)
>>> t.scale(5, 6)
>>>
Nr )r" )r r r r r r scale s zTransform.scalec C s< ddl }t|j|}t|j|}| j||| |ddfS )zReturn a new transformation, rotated by 'angle' (radians).
Example:
>>> import math
>>> t = Transform()
>>> t.rotate(math.pi / 2)
>>>
r N)mathr cossinr" )r Zangler% csr r r rotate s
zTransform.rotatec C s* ddl }| jd|j||j|dddfS )zReturn a new transformation, skewed by x and y.
Example:
>>> import math
>>> t = Transform()
>>> t.skew(math.pi / 4)
>>>
r Nr )r% r" tan)r r r r% r r r skew s
zTransform.skewc C s |\}}}}}}| \}} }
} } }
| j || ||
|| || || ||
|| || || |
| | | | | | |
S )zReturn a new transformation, transformed by another
transformation.
Example:
>>> t = Transform(2, 0, 0, 3, 1, 6)
>>> t.transform((4, 3, 2, 1, 5, 6))
>>>
) __class__)r otherxx1xy1yx1yy1dx1dy1xx2xy2yx2yy2dx2dy2r r r r" s
zTransform.transformc C s | \}}}}}}|\}} }
} } }
| j || ||
|| || || ||
|| || || |
| | | | | | |
S )a Return a new transformation, which is the other transformation
transformed by self. self.reverseTransform(other) is equivalent to
other.transform(self).
Example:
>>> t = Transform(2, 0, 0, 3, 1, 6)
>>> t.reverseTransform((4, 3, 2, 1, 5, 6))
>>> Transform(4, 3, 2, 1, 5, 6).transform((2, 0, 0, 3, 1, 6))
>>>
)r- )r r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: r r r reverseTransform s
zTransform.reverseTransformc C s | t kr | S | \}}}}}}|| || }|| | | | | || f\}}}}| | || | | || }}| j||||||S )zReturn the inverse transformation.
Example:
>>> t = Identity.translate(2, 3).scale(4, 5)
>>> t.transformPoint((10, 20))
(42, 103)
>>> it = t.inverse()
>>> it.transformPoint((42, 103))
(10.0, 20.0)
>>>
)r r- )r r r r r r r Zdetr r r inverse) s (&zTransform.inversec C s d| S )zReturn a PostScript representation:
>>> t = Identity.scale(2, 3).translate(4, 5)
>>> t.toPS()
'[2 0 0 3 8 15]'
>>>
z[%s %s %s %s %s %s]r )r r r r toPS= s zTransform.toPSc C s | t kS )a Returns True if transform is not identity, False otherwise.
>>> bool(Identity)
False
>>> bool(Transform())
False
>>> bool(Scale(1.))
False
>>> bool(Scale(2))
True
>>> bool(Offset())
False
>>> bool(Offset(0))
False
>>> bool(Offset(2))
True
)r )r r r r __bool__F s zTransform.__bool__c C s d| j jf| S )Nz<%s [%g %g %g %g %g %g]>)r- __name__)r r r r __repr__Y s zTransform.__repr__)r r )r N)r r )r?
__module__ __qualname____doc__r floatr r r r r r r r r! r# r$ r* r, r" r; r< r= r> r@ r r r r r E s*
G
c C s t dddd| |S )ztReturn the identity transformation offset by x, y.
Example:
>>> Offset(2, 3)
>>>
r r )r )r r r r r r _ s Nc C s |dkr | }t | dd|ddS )zReturn the identity transformation scaled by x, y. The 'y' argument
may be None, which implies to use the x value for y as well.
Example:
>>> Scale(2, 3)
>>>
Nr )r )r r r r r r i s __main__r )r r )N)rC typingr __all__r
r r r r r r r r? sysdoctestexittestmodfailedr r r r . s