Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.3.90 (git rev e4b24e7fb24c280e1db096edd983ee29e255e3b8)
Geometry module

Detailed Description

This module provides support for:

#include <Eigen/Geometry>

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  Scaling
 Represents a generic uniform scaling transformation. More...
 
class  Eigen::Transform
 Represents an homogeneous transformation in a N dimensional space. More...
 
class  Eigen::Translation
 Represents a translation transformation. More...
 

Typedefs

typedef AngleAxis< double > Eigen::AngleAxisd
 
typedef AngleAxis< float > Eigen::AngleAxisf
 
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::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::hnormalized () const
 column or row-wise homogeneous normalization More...
 
HomogeneousReturnType Eigen::MatrixBase< Derived >::homogeneous () const
 
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...
 
PlainObject Eigen::MatrixBase< Derived >::unitOrthogonal (void) const
 

Typedef Documentation

◆ AngleAxisd

typedef AngleAxis<double> Eigen::AngleAxisd

double precision angle-axis type

◆ AngleAxisf

typedef AngleAxis<float> Eigen::AngleAxisf

single precision angle-axis type

◆ Quaterniond

typedef Quaternion<double> Eigen::Quaterniond

double precision quaternion type

◆ Quaternionf

single precision quaternion type

◆ QuaternionMapAlignedd

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

◆ QuaternionMapAlignedf

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

◆ QuaternionMapd

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

Map an unaligned array of double precision scalars as a quaternion

◆ QuaternionMapf

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

Map an unaligned array of single precision scalars as a quaternion

◆ Rotation2Dd

typedef Rotation2D<double> Eigen::Rotation2Dd

double precision 2D rotation type

◆ Rotation2Df

single precision 2D rotation type

Function Documentation

◆ 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 $ (\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 OtherDerived >
const VectorwiseOp< ExpressionType, Direction >::CrossReturnType Eigen::VectorwiseOp::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.

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

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

See also
class AngleAxis

◆ hnormalized() [1/2]

template<typename Derived >
const MatrixBase< Derived >::HNormalizedReturnType Eigen::MatrixBase< Derived >::hnormalized
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:

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:

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
See also
VectorwiseOp::hnormalized()

◆ hnormalized() [2/2]

const VectorwiseOp< ExpressionType, Direction >::HNormalizedReturnType Eigen::VectorwiseOp::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:

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:

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

See also
MatrixBase::hnormalized()

◆ homogeneous() [1/2]

template<typename Derived >
MatrixBase< Derived >::HomogeneousReturnType Eigen::MatrixBase< Derived >::homogeneous
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:

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:

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
See also
VectorwiseOp::homogeneous(), class Homogeneous

◆ homogeneous() [2/2]

Homogeneous< ExpressionType, Direction > Eigen::VectorwiseOp::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:

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:

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

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.

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

Parameters
srcSource points $ \mathbf{x} = \left( x_1, \hdots, x_n \right) $.
dstDestination points $ \mathbf{y} = \left( y_1, \hdots, y_n \right) $.
with_scalingSets $ 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 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().

See also
cross()
Eigen::MatrixBase::hnormalized
const HNormalizedReturnType hnormalized() const
homogeneous normalization
Definition: Homogeneous.h:172
Eigen::DenseBase::eval
EvalReturnType eval() const
Definition: DenseBase.h:407
Eigen::EigenBase::size
Index size() const
Definition: EigenBase.h:67
Eigen::MatrixBase::UnitZ
static const BasisReturnType UnitZ()
Definition: CwiseNullaryOp.h:871
Eigen::MatrixBase::UnitX
static const BasisReturnType UnitX()
Definition: CwiseNullaryOp.h:851
Eigen::DenseBase::Random
static const RandomReturnType Random()
Definition: Random.h:113
Eigen::DenseCoeffsBase< Derived, WriteAccessors >::w
Scalar & w()
Definition: DenseCoeffsBase.h:461
Eigen::AngleAxisf
AngleAxis< float > AngleAxisf
Definition: AngleAxis.h:157
Eigen::DenseBase::transpose
TransposeReturnType transpose()
Definition: Transpose.h:182
Eigen::DenseCoeffsBase< Derived, ReadOnlyAccessors >::coeff
CoeffReturnType coeff(Index row, Index col) const
Definition: DenseCoeffsBase.h:97