Eigen  3.3.7
Geometry module

Detailed Description

This module provides support for:

#include <Eigen/Geometry>

Modules

Global aligned box typedefs

Classes

class  Eigen::AlignedBox< _Scalar, _AmbientDim >
An axis aligned box. More...

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

class  Eigen::Homogeneous< MatrixType, _Direction >
Expression of one (or a set of) homogeneous vector(s) More...

class  Eigen::Hyperplane< _Scalar, _AmbientDim, _Options >
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< _Scalar, _AmbientDim, _Options >
A parametrized line. More...

class  Eigen::Quaternion< _Scalar, _Options >
The quaternion class used to represent 3D orientations and rotations. More...

class  Eigen::QuaternionBase< Derived >
Base class for quaternion expressions. More...

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

class  Scaling
Represents a generic uniform scaling transformation. More...

class  Eigen::Transform< _Scalar, _Dim, _Mode, _Options >
Represents an homogeneous transformation in a N dimensional space. More...

class  Eigen::Translation< _Scalar, _Dim >
Represents a translation transformation. More...

Typedefs

typedef Transform< double, 2, AffineEigen::Affine2d

typedef Transform< float, 2, AffineEigen::Affine2f

typedef Transform< double, 3, AffineEigen::Affine3d

typedef Transform< float, 3, AffineEigen::Affine3f

typedef Transform< double, 2, AffineCompactEigen::AffineCompact2d

typedef Transform< float, 2, AffineCompactEigen::AffineCompact2f

typedef Transform< double, 3, AffineCompactEigen::AffineCompact3d

typedef Transform< float, 3, AffineCompactEigen::AffineCompact3f

typedef DiagonalMatrix< double, 2 > Eigen::AlignedScaling2d

typedef DiagonalMatrix< float, 2 > Eigen::AlignedScaling2f

typedef DiagonalMatrix< double, 3 > Eigen::AlignedScaling3d

typedef DiagonalMatrix< float, 3 > Eigen::AlignedScaling3f

typedef AngleAxis< double > Eigen::AngleAxisd

typedef AngleAxis< float > Eigen::AngleAxisf

typedef Transform< double, 2, IsometryEigen::Isometry2d

typedef Transform< float, 2, IsometryEigen::Isometry2f

typedef Transform< double, 3, IsometryEigen::Isometry3d

typedef Transform< float, 3, IsometryEigen::Isometry3f

typedef Transform< double, 2, ProjectiveEigen::Projective2d

typedef Transform< float, 2, ProjectiveEigen::Projective2f

typedef Transform< double, 3, ProjectiveEigen::Projective3d

typedef Transform< float, 3, ProjectiveEigen::Projective3f

typedef Quaternion< double > Eigen::Quaterniond

typedef Quaternion< float > Eigen::Quaternionf

typedef Map< Quaternion< double >, AlignedEigen::QuaternionMapAlignedd

typedef Map< Quaternion< float >, AlignedEigen::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 >
PlainObject Eigen::MatrixBase< Derived >::cross (const MatrixBase< OtherDerived > &other) const

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

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

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

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

const HNormalizedReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::hnormalized () const
column or row-wise homogeneous normalization More...

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

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

template<typename Derived , typename Scalar >
operator* (const MatrixBase< Derived > &matrix, const UniformScaling< Scalar > &s)

UniformScaling< float > Eigen::Scaling (float s)

UniformScaling< double > Eigen::Scaling (double s)

template<typename RealScalar >
UniformScaling< std::complex< RealScalar > > Eigen::Scaling (const std::complex< RealScalar > &s)

template<typename Scalar >
DiagonalMatrix< Scalar, 2 > Eigen::Scaling (const Scalar &sx, const Scalar &sy)

template<typename Scalar >
DiagonalMatrix< Scalar, 3 > Eigen::Scaling (const Scalar &sx, const Scalar &sy, const Scalar &sz)

template<typename Derived >
const DiagonalWrapper< const Derived > Eigen::Scaling (const MatrixBase< Derived > &coeffs)

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

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

◆ Affine2d

 typedef Transform Eigen::Affine2d

◆ Affine2f

 typedef Transform Eigen::Affine2f

◆ Affine3d

 typedef Transform Eigen::Affine3d

◆ Affine3f

 typedef Transform Eigen::Affine3f

◆ AffineCompact2d

 typedef Transform Eigen::AffineCompact2d

◆ AffineCompact2f

 typedef Transform Eigen::AffineCompact2f

◆ AffineCompact3d

 typedef Transform Eigen::AffineCompact3d

◆ AffineCompact3f

 typedef Transform Eigen::AffineCompact3f

◆ AlignedScaling2d

 typedef DiagonalMatrix Eigen::AlignedScaling2d

◆ AlignedScaling2f

 typedef DiagonalMatrix Eigen::AlignedScaling2f

◆ AlignedScaling3d

 typedef DiagonalMatrix Eigen::AlignedScaling3d

◆ AlignedScaling3f

 typedef DiagonalMatrix Eigen::AlignedScaling3f

◆ AngleAxisd

 typedef AngleAxis Eigen::AngleAxisd

double precision angle-axis type

◆ AngleAxisf

 typedef AngleAxis Eigen::AngleAxisf

single precision angle-axis type

◆ Isometry2d

 typedef Transform Eigen::Isometry2d

◆ Isometry2f

 typedef Transform Eigen::Isometry2f

◆ Isometry3d

 typedef Transform Eigen::Isometry3d

◆ Isometry3f

 typedef Transform Eigen::Isometry3f

◆ Projective2d

 typedef Transform Eigen::Projective2d

◆ Projective2f

 typedef Transform Eigen::Projective2f

◆ Projective3d

 typedef Transform Eigen::Projective3d

◆ Projective3f

 typedef Transform Eigen::Projective3f

◆ Quaterniond

 typedef Quaternion Eigen::Quaterniond

double precision quaternion type

◆ Quaternionf

 typedef Quaternion Eigen::Quaternionf

single precision quaternion type

◆ QuaternionMapAlignedd

 typedef Map, Aligned> Eigen::QuaternionMapAlignedd

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

◆ QuaternionMapAlignedf

 typedef Map, Aligned> Eigen::QuaternionMapAlignedf

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

◆ QuaternionMapd

 typedef Map, 0> Eigen::QuaternionMapd

Map an unaligned array of double precision scalars as a quaternion

◆ QuaternionMapf

 typedef Map, 0> Eigen::QuaternionMapf

Map an unaligned array of single precision scalars as a quaternion

◆ Rotation2Dd

 typedef Rotation2D Eigen::Rotation2Dd

double precision 2D rotation type

◆ Rotation2Df

 typedef Rotation2D Eigen::Rotation2Df

single precision 2D rotation type

◆ cross() [1/2]

template<typename Derived >
template<typename OtherDerived >
 MatrixBase< Derived >::PlainObject Eigen::MatrixBase< Derived >::cross ( const MatrixBase< OtherDerived > & other ) const
inline

This is defined in the Geometry module.

#include <Eigen/Geometry>
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

MatrixBase::cross3()

◆ cross() [2/2]

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

This is defined in the Geometry module.

#include <Eigen/Geometry>
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.

MatrixBase::cross()

◆ cross3()

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

This is defined in the Geometry module.

#include <Eigen/Geometry>
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.

MatrixBase::cross()

◆ eulerAngles()

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

This is defined in the Geometry module.

#include <Eigen/Geometry>
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:

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

class AngleAxis

◆ hnormalized() [1/2]

template<typename Derived >
 const MatrixBase< Derived >::HNormalizedReturnType Eigen::MatrixBase< Derived >::hnormalized ( ) const
inline

homogeneous normalization

This is defined in the Geometry module.

#include <Eigen/Geometry>
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:

Example:

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:

v                   =   0.68 -0.211  0.566  0.597]^T
v.hnormalized()     =   1.14 -0.354  0.949]^T
P*v                 = 0.663 -0.16 -0.13  0.91]^T
(P*v).hnormalized() =  0.729 -0.176 -0.143]^T

VectorwiseOp::hnormalized()

◆ hnormalized() [2/2]

template<typename ExpressionType , int Direction>
 const VectorwiseOp< ExpressionType, Direction >::HNormalizedReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::hnormalized ( ) const
inline

column or row-wise homogeneous normalization

This is defined in the Geometry module.

#include <Eigen/Geometry>
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:

typedef Matrix<double,4,Dynamic> Matrix4Xd;
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:

The matrix M is:
0.68   0.823  -0.444   -0.27   0.271
-0.211  -0.605   0.108  0.0268   0.435
0.566   -0.33 -0.0452   0.904  -0.717
0.597   0.536   0.258   0.832   0.214

M.colwise().hnormalized():
1.14   1.53  -1.72 -0.325   1.27
-0.354  -1.13  0.419 0.0322   2.03
0.949 -0.614 -0.175   1.09  -3.35

P*M:
0.186  -0.589   0.369    1.33   -1.23
-0.871  -0.337   0.127  -0.715   0.091
-0.158 -0.0104   0.312   0.429  -0.478
0.992   0.777  -0.373   0.468  -0.651

(P*M).colwise().hnormalized():
0.188  -0.759  -0.989    2.85    1.89
-0.877  -0.433  -0.342   -1.53   -0.14
-0.16 -0.0134  -0.837   0.915   0.735


MatrixBase::hnormalized()

◆ homogeneous() [1/2]

template<typename Derived >
 MatrixBase< Derived >::HomogeneousReturnType Eigen::MatrixBase< Derived >::homogeneous ( ) const
inline

This is defined in the Geometry module.

#include <Eigen/Geometry>
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.

This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

Example:

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:

v                                   = [  0.68 -0.211  0.566]^T
h.homogeneous()                     = [  0.68 -0.211  0.566      1]^T
(P * v.homogeneous())               = [  1.27  0.772 0.0154 -0.419]^T
(P * v.homogeneous()).hnormalized() = [  -3.03   -1.84 -0.0367]^T

VectorwiseOp::homogeneous(), class Homogeneous

◆ homogeneous() [2/2]

template<typename ExpressionType , int Direction>
 Homogeneous< ExpressionType, Direction > Eigen::VectorwiseOp< ExpressionType, Direction >::homogeneous ( ) const
inline

This is defined in the Geometry module.

#include <Eigen/Geometry>
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:

typedef Matrix<double,3,Dynamic> Matrix3Xd;
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:

The matrix M is:
0.68   0.597   -0.33   0.108   -0.27
-0.211   0.823   0.536 -0.0452  0.0268
0.566  -0.605  -0.444   0.258   0.904

M.colwise().homogeneous():
0.68   0.597   -0.33   0.108   -0.27
-0.211   0.823   0.536 -0.0452  0.0268
0.566  -0.605  -0.444   0.258   0.904
1       1       1       1       1

P * M.colwise().homogeneous():
0.0832 -0.477  -1.21 -0.545 -0.452
0.998  0.779  0.695  0.894  0.277
-0.271 -0.608 -0.895 -0.544 -0.874
-0.728 -0.551  0.202  -0.21 -0.469

P * M.colwise().homogeneous().hnormalized():
-0.114  0.866     -6    2.6  0.962
-1.37  -1.41   3.44  -4.27 -0.591
0.373    1.1  -4.43    2.6   1.86


MatrixBase::homogeneous(), class Homogeneous

◆ operator*()

template<typename Derived , typename Scalar >
 operator* ( const MatrixBase< Derived > & matrix, const UniformScaling< Scalar > & s )
related

Concatenates a linear transformation matrix and a uniform scaling

◆ Scaling() [1/6]

 UniformScaling Eigen::Scaling ( float s )
inline

Constructs a uniform scaling from scale factor s

◆ Scaling() [2/6]

 UniformScaling Eigen::Scaling ( double s )
inline

Constructs a uniform scaling from scale factor s

◆ Scaling() [3/6]

template<typename RealScalar >
 UniformScaling > Eigen::Scaling ( const std::complex< RealScalar > & s )
inline

Constructs a uniform scaling from scale factor s

◆ Scaling() [4/6]

template<typename Scalar >
 DiagonalMatrix Eigen::Scaling ( const Scalar & sx, const Scalar & sy )
inline

Constructs a 2D axis aligned scaling

◆ Scaling() [5/6]

template<typename Scalar >
 DiagonalMatrix Eigen::Scaling ( const Scalar & sx, const Scalar & sy, const Scalar & sz )
inline

Constructs a 3D axis aligned scaling

◆ Scaling() [6/6]

template<typename Derived >
 const DiagonalWrapper Eigen::Scaling ( const MatrixBase< Derived > & coeffs )
inline

Constructs an axis aligned scaling expression from vector expression coeffs This is an alias for coeffs.asDiagonal()

◆ umeyama()

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

Returns the transformation between two point sets.

This is defined in the Geometry module.

#include <Eigen/Geometry>

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 and such that

is minimized.

The algorithm is based on the analysis of the covariance matrix of the input point sets and where is corresponding to the dimension (which is typically small). The analysis is involving the SVD having a complexity of though the actual computational effort lies in the covariance matrix computation which has an asymptotic lower bound of when the input point sets have dimension .

Currently the method is working only for floating point matrices.

Parameters
 src Source points . dst Destination points . with_scaling Sets when false is passed.
Returns
The homogeneous transformation

minimizing the residual above. This transformation is always returned as an Eigen::Matrix.

◆ unitOrthogonal()

template<typename Derived >
 MatrixBase< Derived >::PlainObject Eigen::MatrixBase< Derived >::unitOrthogonal ( void ) const
inline

This is defined in the Geometry module.

#include <Eigen/Geometry>
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().