| | |
- Transform
class Transform |
| |
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
<Transform [1 0 0 1 0 0]>
>>> t.scale(2)
<Transform [2 0 0 2 0 0]>
>>> t.scale(2.5, 5.5)
<Transform [2.5 0.0 0.0 5.5 0 0]>
>>>
>>> t.scale(2, 3).transformPoint((100, 100))
(200, 300)
|
| |
Methods defined here:
- __cmp__(self, other)
- 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
<Transform [0.2 0.0 0.0 0.3 0.08 0.18]>
>>> t2
<Transform [0.2 0.0 0.0 0.3 0.08 0.18]>
>>> t1 == t2
0
>>>
- __getitem__(self, index)
- Transform instances also behave like sequences of length 6:
>>> list(Identity)
[1, 0, 0, 1, 0, 0]
>>> tuple(Identity)
(1, 0, 0, 1, 0, 0)
>>>
- __getslice__(self, i, j)
- Transform instances also behave like sequences and even support
slicing:
>>> t = Offset(100, 200)
>>> t
<Transform [1 0 0 1 100 200]>
>>> t[4:]
(100, 200)
>>>
- __hash__(self)
- Transform instances are hashable, meaning you can use them as
keys in dictionaries:
>>> d = {Scale(12, 13): None}
>>> d
{<Transform [12 0 0 13 0 0]>: 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
<Transform [0.2 0.0 0.0 0.3 0.08 0.18]>
>>> t2
<Transform [0.2 0.0 0.0 0.3 0.08 0.18]>
>>> d = {t1: None}
>>> d
{<Transform [0.2 0.0 0.0 0.3 0.08 0.18]>: None}
>>> d[t2]
Traceback (most recent call last):
File "<stdin>", line 1, in ?
KeyError: <Transform [0.2 0.0 0.0 0.3 0.08 0.18]>
>>>
- __init__(self, xx=1, xy=0, yx=0, yy=1, dx=0, dy=0)
- Transform's constructor takes six arguments, all of which are
optional, and can be used as keyword arguments:
>>> Transform(12)
<Transform [12 0 0 1 0 0]>
>>> Transform(dx=12)
<Transform [1 0 0 1 12 0]>
>>> Transform(yx=12)
<Transform [1 0 12 1 0 0]>
>>>
- __len__(self)
- Transform instances also behave like sequences of length 6:
>>> len(Identity)
6
>>>
- __repr__(self)
- inverse(self)
- Return 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)
>>>
- reverseTransform(self, other)
- Return a new transformation, which is the other transformation
transformed by 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 [8 6 6 3 21 15]>
>>> Transform(4, 3, 2, 1, 5, 6).transform((2, 0, 0, 3, 1, 6))
<Transform [8 6 6 3 21 15]>
>>>
- rotate(self, angle)
- Return a new transformation, rotated by 'angle' (radians).
Example:
>>> import math
>>> t = Transform()
>>> t.rotate(math.pi / 2)
<Transform [0 1 -1 0 0 0]>
>>>
- scale(self, x=1, y=None)
- 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)
<Transform [5 0 0 5 0 0]>
>>> t.scale(5, 6)
<Transform [5 0 0 6 0 0]>
>>>
- skew(self, x=0, y=0)
- Return a new transformation, skewed by x and y.
Example:
>>> import math
>>> t = Transform()
>>> t.skew(math.pi / 4)
<Transform [1.0 0.0 1.0 1.0 0 0]>
>>>
- toPS(self)
- Return a PostScript representation:
>>> t = Identity.scale(2, 3).translate(4, 5)
>>> t.toPS()
'[2 0 0 3 8 15]'
>>>
- transform(self, other)
- Return a new transformation, transformed by another
transformation.
Example:
>>> t = Transform(2, 0, 0, 3, 1, 6)
>>> t.transform((4, 3, 2, 1, 5, 6))
<Transform [8 9 4 3 11 24]>
>>>
- transformPoint(self, (x, y))
- Transform a point.
Example:
>>> t = Transform()
>>> t = t.scale(2.5, 5.5)
>>> t.transformPoint((100, 100))
(250.0, 550.0)
- transformPoints(self, points)
- Transform 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)]
>>>
- translate(self, x=0, y=0)
- Return a new transformation, translated (offset) by x, y.
Example:
>>> t = Transform()
>>> t.translate(20, 30)
<Transform [1 0 0 1 20 30]>
>>>
| |