Navigation: Up   Table of Contents   Package Overview   Bibliography   Index   Title   Acknowledging CGAL
Class

CGAL::Aff_transformation_d<Kernel>

Definition

An instance of the data type Aff_transformation_d<Kernel> is an affine transformation of d-dimensional space. It is specified by a square matrix M of dimension d + 1. All entries in the last row of M except the diagonal entry must be zero; the diagonal entry must be non-zero. A point p with homogeneous coordinates (p[0], … , p[d]) can be transformed into the point p.transform(A) = Mp, where A is an affine transformation created from M by the constructors below.

Types

Aff_transformation_d<Kernel>::LA
the linear algebra layer.


Aff_transformation_d<Kernel>::Matrix
the matrix type.

Creation

Aff_transformation_d<Kernel> t;
introduces some transformation.


Aff_transformation_d<Kernel> t ( int d, Identity_transformation);
introduces the identity transformation in d-dimensional space.


Aff_transformation_d<Kernel> t ( Matrix M);
introduces the transformation of d-space specified by matrix M.
Precondition: M is a square matrix of dimension d + 1 where entries in the last row of M except the diagonal entry must be zero; the diagonal entry must be non-zero.


template <typename Forward_iterator>
Aff_transformation_d<Kernel> t ( Scaling, Forward_iterator start, Forward_iterator end);
introduces the transformation of d-space specified by a diagonal matrix with entries set [start,end) on the diagonal (a scaling of the space).
Precondition: set [start,end) is a vector of dimension d+1.


Aff_transformation_d<Kernel> t ( Translation, Vector_d<Kernel> v);
introduces the translation by vector v.


Aff_transformation_d<Kernel> t ( int d, Scaling, RT num, RT den);
returns a scaling by a scale factor num/den.
Precondition: den !=0 .


Aff_transformation_d<Kernel> t ( int d, Rotation, RT sin_num, RT cos_num, RT den, int e1 = 0, int e2 = 1);
returns a planar rotation with sine and cosine values sin_num/den and cos_num/den in the plane spanned by the base vectors be1 and be2 in d-space. Thus the default use delivers a planar rotation in the x-y plane.
Precondition: sin_num2 + cos_num2 = den2 and 0 ≤ e1 < e2 < d.
Precondition: den != 0


Aff_transformation_d<Kernel> t ( int d, Rotation, Direction_d<Kernel> dir, RT num, RT den, int e1 = 0, int e2 = 1);
returns a planar rotation within a two-dimensional linear subspace. The subspace is spanned by the base vectors be1 and be2 in d-space. The rotation parameters are given by the 2-dimensional direction dir, such that the difference between the sines and cosines of the rotation given by dir and the approximated rotation are at most num/den each.
Precondition: dir.dimension()==2, !dir.is_degenerate() and num < den is positive, den != 0, 0 ≤ e1 < e2 < d.

Operations

int t.dimension () the dimension of the underlying space

Matrix t.matrix () returns the transformation matrix

Aff_transformation_d<Kernel> t.inverse () returns the inverse transformation.
Precondition: t.matrix() is invertible.

Aff_transformation_d<Kernel> t * s composition of transformations. Note that transformations are not necessarily commutative. t*s is the transformation which transforms first by t and then by s.

Implementation

Affine Transformations are implemented by matrices of number type RT as a handle type. All operations like creation, initialization, input and output on a transformation t take time O(t.dimension()2). dimension() takes constant time. The operations for inversion and composition have the cubic costs of the used matrix operations. The space requirement is O(t.dimension()2).

Next: affinely_independent
Navigation: Up   Table of Contents   Package Overview   Bibliography   Index   Title   Acknowledging CGAL
CGAL Open Source Project. Release 4.0.2. 4 July 2012.