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>::RT
	the ring type.
Aff_transformation_d<Kernel>::FT
	the field type.
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()²). 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()²).