Modules
	Global aligned box typedefs
	Eigen defines several typedef shortcuts for most common aligned box types.

Classes
class	Eigen::Map< const Quaternion< _Scalar >, _Options >
	Quaternion expression mapping a constant memory buffer. More...

class	Eigen::Map< Quaternion< _Scalar >, _Options >
	Expression of a quaternion from a memory buffer. More...

class	Eigen::AlignedBox< _Scalar, _AmbientDim >

class	Eigen::AngleAxis< _Scalar >

class	Eigen::Homogeneous< MatrixType, _Direction >

class	Eigen::Hyperplane< _Scalar, _AmbientDim, _Options >

class	Eigen::ParametrizedLine< _Scalar, _AmbientDim, _Options >

class	Eigen::QuaternionBase< Derived >

class	Eigen::Quaternion< _Scalar, _Options >

class	Eigen::Rotation2D< _Scalar >

class	Scaling

class	Eigen::Transform< _Scalar, _Dim, _Mode, _Options >

class	Eigen::Translation< _Scalar, _Dim >

Typedefs
typedef AngleAxis< float >	Eigen::AngleAxisf
	single precision angle-axis type

typedef AngleAxis< double >	Eigen::AngleAxisd
	double precision angle-axis type

typedef Quaternion< float >	Eigen::Quaternionf
	single precision quaternion type

typedef Quaternion< double >	Eigen::Quaterniond
	double precision quaternion type

typedef Map< Quaternion< float >, 0 >	Eigen::QuaternionMapf
	Map an unaligned array of single precision scalars as a quaternion.

typedef Map< Quaternion< double >, 0 >	Eigen::QuaternionMapd
	Map an unaligned array of double precision scalars as a quaternion.

typedef Map< Quaternion< float >, Aligned >	Eigen::QuaternionMapAlignedf
	Map a 16-byte aligned array of single precision scalars as a quaternion.

typedef Map< Quaternion< double >, Aligned >	Eigen::QuaternionMapAlignedd
	Map a 16-byte aligned array of double precision scalars as a quaternion.

typedef Rotation2D< float >	Eigen::Rotation2Df
	single precision 2D rotation type

typedef Rotation2D< double >	Eigen::Rotation2Dd
	double precision 2D rotation type

typedef DiagonalMatrix< float, 2 >	Eigen::AlignedScaling2f

typedef DiagonalMatrix< double, 2 >	Eigen::AlignedScaling2d

typedef DiagonalMatrix< float, 3 >	Eigen::AlignedScaling3f

typedef DiagonalMatrix< double, 3 >	Eigen::AlignedScaling3d

typedef Transform< float, 2, Isometry >	Eigen::Isometry2f

typedef Transform< float, 3, Isometry >	Eigen::Isometry3f

typedef Transform< double, 2, Isometry >	Eigen::Isometry2d

typedef Transform< double, 3, Isometry >	Eigen::Isometry3d

typedef Transform< float, 2, Affine >	Eigen::Affine2f

typedef Transform< float, 3, Affine >	Eigen::Affine3f

typedef Transform< double, 2, Affine >	Eigen::Affine2d

typedef Transform< double, 3, Affine >	Eigen::Affine3d

typedef Transform< float, 2, AffineCompact >	Eigen::AffineCompact2f

typedef Transform< float, 3, AffineCompact >	Eigen::AffineCompact3f

typedef Transform< double, 2, AffineCompact >	Eigen::AffineCompact2d

typedef Transform< double, 3, AffineCompact >	Eigen::AffineCompact3d

typedef Transform< float, 2, Projective >	Eigen::Projective2f

typedef Transform< float, 3, Projective >	Eigen::Projective3f

typedef Transform< double, 2, Projective >	Eigen::Projective2d

typedef Transform< double, 3, Projective >	Eigen::Projective3d

typedef Translation< float, 2 >	Eigen::Translation2f

typedef Translation< double, 2 >	Eigen::Translation2d

typedef Translation< float, 3 >	Eigen::Translation3f

typedef Translation< double, 3 >	Eigen::Translation3d

Functions
UniformScaling< float >	Eigen::Scaling (float s)
	Constructs a uniform scaling from scale factor s.

UniformScaling< double >	Eigen::Scaling (double s)
	Constructs a uniform scaling from scale factor s.

template<typename RealScalar >
UniformScaling< std::complex< RealScalar > >	Eigen::Scaling (const std::complex< RealScalar > &s)
	Constructs a uniform scaling from scale factor s.

template<typename Scalar >
DiagonalMatrix< Scalar, 2 >	Eigen::Scaling (const Scalar &sx, const Scalar &sy)
	Constructs a 2D axis aligned scaling.

template<typename Scalar >
DiagonalMatrix< Scalar, 3 >	Eigen::Scaling (const Scalar &sx, const Scalar &sy, const Scalar &sz)
	Constructs a 3D axis aligned scaling.

template<typename Derived >
const DiagonalWrapper< const Derived >	Eigen::Scaling (const MatrixBase< Derived > &coeffs)
	Constructs an axis aligned scaling expression from vector expression coeffs This is an alias for coeffs.asDiagonal()

template<typename Derived , typename OtherDerived >
internal::umeyama_transform_matrix_type< Derived, OtherDerived >::type	Eigen::umeyama (const MatrixBase< Derived > &src, const MatrixBase< OtherDerived > &dst, bool with_scaling=true)

EIGEN_DEVICE_FUNC Matrix< Scalar, 3, 1 >	Eigen::MatrixBase< Derived >::eulerAngles (Index a0, Index a1, Index a2) const

EIGEN_DEVICE_FUNC HomogeneousReturnType	Eigen::MatrixBase< Derived >::homogeneous () const

EIGEN_DEVICE_FUNC HomogeneousReturnType	Eigen::VectorwiseOp< ExpressionType, Direction >::homogeneous () const

EIGEN_DEVICE_FUNC const HNormalizedReturnType	Eigen::MatrixBase< Derived >::hnormalized () const

EIGEN_DEVICE_FUNC const HNormalizedReturnType	Eigen::VectorwiseOp< ExpressionType, Direction >::hnormalized () const

template<typename OtherDerived >
EIGEN_DEVICE_FUNC MatrixBase< Derived >::template cross_product_return_type< OtherDerived >::type	Eigen::MatrixBase< Derived >::cross (const MatrixBase< OtherDerived > &other) const

template<typename OtherDerived >
EIGEN_DEVICE_FUNC PlainObject	Eigen::MatrixBase< Derived >::cross3 (const MatrixBase< OtherDerived > &other) const

template<typename OtherDerived >
EIGEN_DEVICE_FUNC const CrossReturnType	Eigen::VectorwiseOp< ExpressionType, Direction >::cross (const MatrixBase< OtherDerived > &other) const

EIGEN_DEVICE_FUNC PlainObject	Eigen::MatrixBase< Derived >::unitOrthogonal (void) const

template<typename Derived , typename Scalar >
	operator* (const MatrixBase< Derived > &matrix, const UniformScaling< Scalar > &s)
	Concatenates a linear transformation matrix and a uniform scaling.

Detailed Description

Typedef Documentation

§ AlignedScaling2d

typedef DiagonalMatrix<double,2> Eigen::AlignedScaling2d

Deprecated:

§ AlignedScaling2f

typedef DiagonalMatrix<float, 2> Eigen::AlignedScaling2f

Deprecated:

§ AlignedScaling3d

typedef DiagonalMatrix<double,3> Eigen::AlignedScaling3d

Deprecated:

§ AlignedScaling3f

typedef DiagonalMatrix<float, 3> Eigen::AlignedScaling3f

Deprecated:

Function Documentation

§ cross() [1/2]

template<typename Derived>

template<typename OtherDerived >

EIGEN_DEVICE_FUNC MatrixBase<Derived>::template cross_product_return_type<OtherDerived>::type Eigen::MatrixBase< Derived >::cross ( const MatrixBase< OtherDerived > & other ) const

inline

Returns: the cross product of *this and other

Here is a very good explanation of cross-product: http://xkcd.com/199/

With complex numbers, the cross product is implemented as \( (\mathbf{a}+i\mathbf{b}) \times (\mathbf{c}+i\mathbf{d}) = (\mathbf{a} \times \mathbf{c} - \mathbf{b} \times \mathbf{d}) - i(\mathbf{a} \times \mathbf{d} - \mathbf{b} \times \mathbf{c})\)

See also: MatrixBase::cross3()

§ cross() [2/2]

template<typename ExpressionType , int Direction>

template<typename OtherDerived >

EIGEN_DEVICE_FUNC const VectorwiseOp< ExpressionType, Direction >::CrossReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::cross ( const MatrixBase< OtherDerived > & other ) const

Returns: a matrix expression of the cross product of each column or row of the referenced expression with the other vector.

The referenced matrix must have one dimension equal to 3. The result matrix has the same dimensions than the referenced one.

See also: MatrixBase::cross()

§ cross3()

template<typename Derived >

template<typename OtherDerived >

EIGEN_DEVICE_FUNC MatrixBase< Derived >::PlainObject Eigen::MatrixBase< Derived >::cross3 ( const MatrixBase< OtherDerived > & other ) const

inline

Returns: the cross product of *this and other using only the x, y, and z coefficients

The size of *this and other must be four. This function is especially useful when using 4D vectors instead of 3D ones to get advantage of SSE/AltiVec vectorization.

See also: MatrixBase::cross()

§ eulerAngles()

template<typename Derived >

EIGEN_DEVICE_FUNC Matrix< typename MatrixBase< Derived >::Scalar, 3, 1 > Eigen::MatrixBase< Derived >::eulerAngles	(	Index	a0,
		Index	a1,
		Index	a2
	)		const

inline

Returns: the Euler-angles of the rotation matrix *this using the convention defined by the triplet (a0,a1,a2)

Each of the three parameters a0,a1,a2 represents the respective rotation axis as an integer in {0,1,2}. For instance, in:

Vector3f ea = mat.eulerAngles(2, 0, 2);

"2" represents the z axis and "0" the x axis, etc. The returned angles are such that we have the following equality:

mat == AngleAxisf(ea[0], Vector3f::UnitZ())
     * AngleAxisf(ea[1], Vector3f::UnitX())
     * AngleAxisf(ea[2], Vector3f::UnitZ()); 

This corresponds to the right-multiply conventions (with right hand side frames).

The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi].

See also: class AngleAxis

§ hnormalized() [1/2]

template<typename Derived >

EIGEN_DEVICE_FUNC const MatrixBase< Derived >::HNormalizedReturnType Eigen::MatrixBase< Derived >::hnormalized ( ) const

inline

homogeneous normalization

Returns: a vector expression of the N-1 first coefficients of *this divided by that last coefficient.

This can be used to convert homogeneous coordinates to affine coordinates.

It is essentially a shortcut for:

this->head(this->size()-1)/this->coeff(this->size()-1);

Example:

Output:

See also: VectorwiseOp::hnormalized()

§ hnormalized() [2/2]

template<typename ExpressionType , int Direction>

EIGEN_DEVICE_FUNC const VectorwiseOp< ExpressionType, Direction >::HNormalizedReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::hnormalized ( ) const

inline

column or row-wise homogeneous normalization

Returns: an expression of the first N-1 coefficients of each column (or row) of *this divided by the last coefficient of each column (or row).

This can be used to convert homogeneous coordinates to affine coordinates.

It is conceptually equivalent to calling MatrixBase::hnormalized() to each column (or row) of *this.

Example:

Output:

See also: MatrixBase::hnormalized()

§ homogeneous() [1/2]

template<typename Derived >

EIGEN_DEVICE_FUNC MatrixBase< Derived >::HomogeneousReturnType Eigen::MatrixBase< Derived >::homogeneous ( ) const

inline

Returns: a vector expression that is one longer than the vector argument, with the value 1 symbolically appended as the last coefficient.

This can be used to convert affine coordinates to homogeneous coordinates.

Example:

Output:

See also: VectorwiseOp::homogeneous(), class Homogeneous

§ homogeneous() [2/2]

template<typename ExpressionType , int Direction>

EIGEN_DEVICE_FUNC Homogeneous< ExpressionType, Direction > Eigen::VectorwiseOp< ExpressionType, Direction >::homogeneous ( ) const

inline

Returns: an expression where the value 1 is symbolically appended as the final coefficient to each column (or row) of the matrix.

This can be used to convert affine coordinates to homogeneous coordinates.

Example:

Output:

See also: MatrixBase::homogeneous(), class Homogeneous

§ umeyama()

template<typename Derived , typename OtherDerived >

internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type Eigen::umeyama	(	const MatrixBase< Derived > &	src,
		const MatrixBase< OtherDerived > &	dst,
		bool	with_scaling = `true`
	)

Returns the transformation between two point sets.

The algorithm is based on: "Least-squares estimation of transformation parameters between two point patterns", Shinji Umeyama, PAMI 1991, DOI: 10.1109/34.88573

It estimates parameters \( c, \mathbf{R}, \) and \( \mathbf{t} \) such that

\begin{align*} \frac{1}{n} \sum_{i=1}^n \vert\vert y_i - (c\mathbf{R}x_i + \mathbf{t}) \vert\vert_2^2 \end{align*}

is minimized.

The algorithm is based on the analysis of the covariance matrix \( \Sigma_{\mathbf{x}\mathbf{y}} \in \mathbb{R}^{d \times d} \) of the input point sets \( \mathbf{x} \) and \( \mathbf{y} \) where \(d\) is corresponding to the dimension (which is typically small). The analysis is involving the SVD having a complexity of \(O(d^3)\) though the actual computational effort lies in the covariance matrix computation which has an asymptotic lower bound of \(O(dm)\) when the input point sets have dimension \(d \times m\).

Currently the method is working only for floating point matrices.

Todo:: Should the return type of umeyama() become a Transform?

Parameters

src	Source points \( \mathbf{x} = \left( x_1, \hdots, x_n \right) \).
dst	Destination points \( \mathbf{y} = \left( y_1, \hdots, y_n \right) \).
with_scaling	Sets \( c=1 \) when `false` is passed.

Returns: The homogeneous transformation
\begin{align*} T = \begin{bmatrix} c\mathbf{R} & \mathbf{t} \\ \mathbf{0} & 1 \end{bmatrix} \end{align*}
minimizing the resudiual above. This transformation is always returned as an Eigen::Matrix.

§ unitOrthogonal()

template<typename Derived >

EIGEN_DEVICE_FUNC MatrixBase< Derived >::PlainObject Eigen::MatrixBase< Derived >::unitOrthogonal ( void ) const

inline

Returns: a unit vector which is orthogonal to *this

The size of *this must be at least 2. If the size is exactly 2, then the returned vector is a counter clock wise rotation of *this, i.e., (-y,x).normalized().

See also: cross()

Modules

Classes

Typedefs

Functions

Detailed Description

Typedef Documentation

§ AlignedScaling2d

§ AlignedScaling2f

§ AlignedScaling3d

§ AlignedScaling3f

Function Documentation

§ cross() [1/2]

§ cross() [2/2]

§ cross3()

§ eulerAngles()

§ hnormalized() [1/2]

§ hnormalized() [2/2]

§ homogeneous() [1/2]

§ homogeneous() [2/2]

§ umeyama()

§ unitOrthogonal()