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

Data Structures
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 >
	\geometry_module More...

class	Eigen::AngleAxis< _Scalar >
	\geometry_module More...

class	Eigen::Homogeneous< MatrixType, _Direction >
	\geometry_module More...

class	Eigen::Hyperplane< _Scalar, _AmbientDim, _Options >
	\geometry_module More...

class	Eigen::ParametrizedLine< _Scalar, _AmbientDim, _Options >
	\geometry_module More...

class	Eigen::QuaternionBase< Derived >
	\geometry_module More...

class	Eigen::Quaternion< _Scalar, _Options >
	\geometry_module More...

class	Eigen::Rotation2D< _Scalar >
	\geometry_module More...

class	Scaling
	\geometry_module More...

class	Eigen::Transform< _Scalar, _Dim, _Mode, _Options >
	\geometry_module More...

class	Eigen::Translation< _Scalar, _Dim >
	\geometry_module More...

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 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

Functions
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)
	\geometry_module

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

Detailed Description

Function Documentation

◆ eulerAngles()

template<typename Derived >

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

inline

\geometry_module

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);

Eigen::Solve

Pseudo expression representing a solving operation.

Definition Solve.h:63

"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

◆ 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`
	)

\geometry_module

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 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.

Modules

Data Structures

Typedefs

Functions

Detailed Description

Function Documentation

◆ eulerAngles()

◆ umeyama()