Collaboration diagram for Geometry_Module:

Modules
	Global aligned box typedefs

Classes
class	Eigen::AlignedBox
	An axis aligned box. More...

class	Eigen::AngleAxis
	Represents a 3D rotation as a rotation angle around an arbitrary 3D axis. More...

class	Eigen::Homogeneous
	Expression of one (or a set of) homogeneous vector(s) More...

class	Eigen::Hyperplane
	A hyperplane. More...

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::ParametrizedLine
	A parametrized line. More...

class	Eigen::Quaternion
	The quaternion class used to represent 3D orientations and rotations. More...

class	Eigen::QuaternionBase
	Base class for quaternion expressions. More...

class	Eigen::Rotation2D
	Represents a rotation/orientation in a 2 dimensional space. More...

class	Eigen::Transform
	Represents an homogeneous transformation in a N dimensional space. More...

class	Eigen::Translation
	Represents a translation transformation. More...

class	Eigen::UniformScaling
	Represents a generic uniform scaling transformation. More...

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

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

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

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

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

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

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

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

typedef AngleAxis< double >	Eigen::AngleAxisd

typedef AngleAxis< float >	Eigen::AngleAxisf

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

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

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

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

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

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

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

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

typedef Quaternion< double >	Eigen::Quaterniond

typedef Quaternion< float >	Eigen::Quaternionf

typedef Map< Quaternion< double >, Aligned >	Eigen::QuaternionMapAlignedd

typedef Map< Quaternion< float >, Aligned >	Eigen::QuaternionMapAlignedf

typedef Map< Quaternion< double >, 0 >	Eigen::QuaternionMapd

typedef Map< Quaternion< float >, 0 >	Eigen::QuaternionMapf

typedef Rotation2D< double >	Eigen::Rotation2Dd

typedef Rotation2D< float >	Eigen::Rotation2Df

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

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

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

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

const EIGEN_DEVICE_FUNC HNormalizedReturnType	Eigen::MatrixBase< Derived >::hnormalized () const
	homogeneous normalization More...

const EIGEN_DEVICE_FUNC HNormalizedReturnType	Eigen::VectorwiseOp::hnormalized () const
	column or row-wise homogeneous normalization More...

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

EIGEN_DEVICE_FUNC HomogeneousReturnType	Eigen::VectorwiseOp::homogeneous () const

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

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

Detailed Description

Typedef Documentation

◆ Affine2d

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

Definition at line 708 of file Transform.h.

◆ Affine2f

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

Definition at line 704 of file Transform.h.

◆ Affine3d

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

Definition at line 710 of file Transform.h.

◆ Affine3f

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

Definition at line 706 of file Transform.h.

◆ AffineCompact2d

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

Definition at line 717 of file Transform.h.

◆ AffineCompact2f

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

Definition at line 713 of file Transform.h.

◆ AffineCompact3d

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

Definition at line 719 of file Transform.h.

◆ AffineCompact3f

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

Definition at line 715 of file Transform.h.

◆ AngleAxisd

typedef AngleAxis<double> Eigen::AngleAxisd

double precision angle-axis type

Definition at line 160 of file AngleAxis.h.

◆ AngleAxisf

typedef AngleAxis<float> Eigen::AngleAxisf

single precision angle-axis type

Definition at line 157 of file AngleAxis.h.

◆ Isometry2d

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

Definition at line 699 of file Transform.h.

◆ Isometry2f

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

Definition at line 695 of file Transform.h.

◆ Isometry3d

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

Definition at line 701 of file Transform.h.

◆ Isometry3f

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

Definition at line 697 of file Transform.h.

◆ Projective2d

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

Definition at line 726 of file Transform.h.

◆ Projective2f

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

Definition at line 722 of file Transform.h.

◆ Projective3d

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

Definition at line 728 of file Transform.h.

◆ Projective3f

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

Definition at line 724 of file Transform.h.

◆ Quaterniond

typedef Quaternion<double> Eigen::Quaterniond

double precision quaternion type

Definition at line 366 of file 3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h.

◆ Quaternionf

typedef Quaternion<float> Eigen::Quaternionf

single precision quaternion type

Definition at line 363 of file 3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h.

◆ QuaternionMapAlignedd

typedef Map<Quaternion<double>, Aligned> Eigen::QuaternionMapAlignedd

Map a 16-byte aligned array of double precision scalars as a quaternion

Definition at line 478 of file 3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h.

◆ QuaternionMapAlignedf

typedef Map<Quaternion<float>, Aligned> Eigen::QuaternionMapAlignedf

Map a 16-byte aligned array of single precision scalars as a quaternion

Definition at line 475 of file 3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h.

◆ QuaternionMapd

typedef Map<Quaternion<double>, 0> Eigen::QuaternionMapd

Map an unaligned array of double precision scalars as a quaternion

Definition at line 472 of file 3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h.

◆ QuaternionMapf

typedef Map<Quaternion<float>, 0> Eigen::QuaternionMapf

Map an unaligned array of single precision scalars as a quaternion

Definition at line 469 of file 3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h.

◆ Rotation2Dd

typedef Rotation2D<double> Eigen::Rotation2Dd

double precision 2D rotation type

Definition at line 168 of file Rotation2D.h.

◆ Rotation2Df

typedef Rotation2D<float> Eigen::Rotation2Df

single precision 2D rotation type

Definition at line 165 of file Rotation2D.h.

Function Documentation

◆ cross() [1/2]

template<typename Derived >

template<typename OtherDerived >

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

\geometry_module

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

Definition at line 35 of file OrthoMethods.h.

◆ cross() [2/2]

template<typename OtherDerived >

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

\geometry_module

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

Definition at line 111 of file OrthoMethods.h.

◆ cross3()

template<typename Derived >

template<typename OtherDerived >

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

inline

\geometry_module

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

Definition at line 83 of file OrthoMethods.h.

◆ 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

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

"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

Definition at line 37 of file Eigen/src/Geometry/EulerAngles.h.

◆ hnormalized() [1/2]

template<typename Derived >

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

inline

homogeneous normalization

\geometry_module

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:

Vector4d v = Vector4d::Random();
Projective3d P(Matrix4d::Random());
cout << "v                   = " << v.transpose() << "]^T" << endl;
cout << "v.hnormalized()     = " << v.hnormalized().transpose() << "]^T" << endl;
cout << "P*v                 = " << (P*v).transpose() << "]^T" << endl;
cout << "(P*v).hnormalized() = " << (P*v).hnormalized().transpose() << "]^T" << endl;

Output:

See also: VectorwiseOp::hnormalized()

Definition at line 174 of file Homogeneous.h.

◆ hnormalized() [2/2]

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

inline

column or row-wise homogeneous normalization

\geometry_module

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:

Matrix4Xd M = Matrix4Xd::Random(4,5);
Projective3d P(Matrix4d::Random());
cout << "The matrix M is:" << endl << M << endl << endl;
cout << "M.colwise().hnormalized():" << endl << M.colwise().hnormalized() << endl << endl;
cout << "P*M:" << endl << P*M << endl << endl;
cout << "(P*M).colwise().hnormalized():" << endl << (P*M).colwise().hnormalized() << endl << endl;

Output:

See also: MatrixBase::hnormalized()

Definition at line 198 of file Homogeneous.h.

◆ homogeneous() [1/2]

template<typename Derived >

EIGEN_DEVICE_FUNC MatrixBase< Derived >::HomogeneousReturnType Eigen::MatrixBase< Derived >::homogeneous

inline

\geometry_module

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.

\only_for_vectors

Example:

Vector3d v = Vector3d::Random(), w;
Projective3d P(Matrix4d::Random());
cout << "v                                   = [" << v.transpose() << "]^T" << endl;
cout << "h.homogeneous()                     = [" << v.homogeneous().transpose() << "]^T" << endl;
cout << "(P * v.homogeneous())               = [" << (P * v.homogeneous()).transpose() << "]^T" << endl;
cout << "(P * v.homogeneous()).hnormalized() = [" << (P * v.homogeneous()).eval().hnormalized().transpose() << "]^T" << endl;

Output:

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

Definition at line 132 of file Homogeneous.h.

◆ homogeneous() [2/2]

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

inline

\geometry_module

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:

Matrix3Xd M = Matrix3Xd::Random(3,5);
Projective3d P(Matrix4d::Random());
cout << "The matrix M is:" << endl << M << endl << endl;
cout << "M.colwise().homogeneous():" << endl << M.colwise().homogeneous() << endl << endl;
cout << "P * M.colwise().homogeneous():" << endl << P * M.colwise().homogeneous() << endl << endl;
cout << "P * M.colwise().homogeneous().hnormalized(): " << endl << (P * M.colwise().homogeneous()).colwise().hnormalized() << endl << endl;

Output:

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

Definition at line 150 of file Homogeneous.h.

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

\geometry_module

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 residual above. This transformation is always returned as an Eigen::Matrix.

Definition at line 95 of file Umeyama.h.

◆ unitOrthogonal()

template<typename Derived >

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

inline

\geometry_module

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

Definition at line 227 of file OrthoMethods.h.

Modules

Classes

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ Affine2d

◆ Affine2f

◆ Affine3d

◆ Affine3f

◆ AffineCompact2d

◆ AffineCompact2f

◆ AffineCompact3d

◆ AffineCompact3f

◆ AngleAxisd

◆ AngleAxisf

◆ Isometry2d

◆ Isometry2f

◆ Isometry3d

◆ Isometry3f

◆ Projective2d

◆ Projective2f

◆ Projective3d

◆ Projective3f

◆ Quaterniond

◆ Quaternionf

◆ QuaternionMapAlignedd

◆ QuaternionMapAlignedf

◆ QuaternionMapd

◆ QuaternionMapf

◆ Rotation2Dd

◆ Rotation2Df

Function Documentation

◆ cross() [1/2]

◆ cross() [2/2]

◆ cross3()

◆ eulerAngles()

◆ hnormalized() [1/2]

◆ hnormalized() [2/2]

◆ homogeneous() [1/2]

◆ homogeneous() [2/2]

◆ umeyama()

◆ unitOrthogonal()