API Reference for Enthought Tool Suite 3.0.1

             a    b    0
[x, y, 1] *  c    d    0 = [x',y',1]
             tx   ty   1

Variables

• IDENTITY

  IDENTITY = affine_identity()
  
  

Function summary

• affine_from_rotation(angle)
• affine_from_scale(sx, sy)
• affine_from_translation(x, y)
• affine_from_values(a, b, c, d, tx, ty)
• affine_identity()
• affine_params(m)
• concat(transform, other)
• invert(m)
• is_identity(m)
• rotate(transform, angle)
• scale(transform, sx, sy)
• transform_point(ctm, pt)
• transform_points(ctm, pts)
• translate(transform, x, y)
• trs_factor(m)

Functions

• affine_from_rotation(angle)

  Returns an affine transform rotated by angle in radians.

• affine_from_scale(sx, sy)

  Returns an affine transform providing the given scaling.

• affine_from_translation(x, y)

  Returns an affine transform with the given translation.

• affine_from_values(a, b, c, d, tx, ty)
• affine_identity()

  Returns a new identity affine_transform object.

• affine_params(m)

  Returns the a, b, c, d, tx, ty values of an affine transform.

• concat(transform, other)

  Returns the concatenation of transform with other. This is simply transform pre-multiplied by other.

• invert(m)

  Returns the inverse of the transform, m.

• is_identity(m)

  Tests whether an affine transform is the identity transform.

• rotate(transform, angle)

  Rotates transform by angle in radians.

  Rotation is done using the following formula:

   cos(x)  sin(x)  0       a  b   0
  -sin(x)  cos(x)  0   *   c  d   0 =
     0       0     1      tx ty   1
  

   cos(x)*a+sin(x)*b   cos(x)*b+sin(x)*d    0
  -sin(x)*a+cos(x)*c  -sin(x)*b+cos(x)*d    0
           tx                  ty           1
  

  where x = angle.

• scale(transform, sx, sy)

  Returns a scaled version of the transform by the given values.

  Scaling is done using the following formula:

  sx  0  0     a  b  0      sx*a sx*b  0
  0  sy  0  *  c  d  0  =   sy*c sy*d  0
  0   0  1    tx ty  1       0    0    1
  

• transform_point(ctm, pt)

  Returns pt transformed by the affine transform, ctm.

• transform_points(ctm, pts)

  Transforms an array of points using the affine transform, ctm.

• translate(transform, x, y)

  Returns transform translated by (x,y).

  Translation:

  1  0  0      a   b   0         a          b        0
  0  1  0   *  c   d   0  =      c          d        0
  x  y  1     tx  ty   1     x*a+y*c+y  x*b+y*d+ty   1
  

• trs_factor(m)

  Factors a matrix as if it is the product of translate/rotate/scale matrices applied (i.e., concatenated) in that order. It returns:

  tx,ty,sx,sy,angle

  where tx and ty are the translations, sx and sy are the scaling values and angle is the rotational angle in radians.

  If the input matrix was created in a way other than concatenating t/r/s matrices, the results could be wrong. For example, if there is any skew in the matrix, the returned results are wrong.

  Needs Test!

Imported Names

© Copyright 2002-2008 Enthought, Inc.