Eigen::EulerAngles< Scalar_, _System > Class Template Reference

Represents a rotation in a 3 dimensional space as three Euler angles. More...

Inheritance diagram for Eigen::EulerAngles< Scalar_, _System >:

Public Types
typedef AngleAxis< Scalar >	AngleAxisType
typedef RotationBase< EulerAngles< Scalar_, _System >, 3 >	Base
typedef Matrix< Scalar, 3, 3 >	Matrix3
typedef Quaternion< Scalar >	QuaternionType
typedef NumTraits< Scalar >::Real	RealScalar
typedef Scalar_	Scalar
typedef _System	System
typedef Matrix< Scalar, 3, 1 >	Vector3
Public Types inherited from Eigen::RotationBase< EulerAngles< Scalar_, _System >, 3 >
typedef Matrix< Scalar, Dim, Dim >	RotationMatrixType
typedef internal::traits< Derived >::Scalar	Scalar
typedef Matrix< Scalar, Dim, 1 >	VectorType

Public Member Functions
Scalar &	alpha ()
Scalar	alpha () const
Vector3 &	angles ()
const Vector3 &	angles () const
Scalar &	beta ()
Scalar	beta () const
template<typename NewScalarType >
EulerAngles< NewScalarType, System >	cast () const
	EulerAngles ()
template<typename Derived >
	EulerAngles (const MatrixBase< Derived > &other)
template<typename Derived >
	EulerAngles (const RotationBase< Derived, 3 > &rot)
	EulerAngles (const Scalar &alpha, const Scalar &beta, const Scalar &gamma)
	EulerAngles (const Scalar *data)
Scalar &	gamma ()
Scalar	gamma () const
EulerAngles	inverse () const
bool	isApprox (const EulerAngles &other, const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
	operator QuaternionType () const
EulerAngles	operator- () const
template<class Derived >
EulerAngles &	operator= (const MatrixBase< Derived > &other)
template<typename Derived >
EulerAngles &	operator= (const RotationBase< Derived, 3 > &rot)
Matrix3	toRotationMatrix () const
Public Member Functions inherited from Eigen::RotationBase< EulerAngles< Scalar_, _System >, 3 >
VectorType	_transformVector (const OtherVectorType &v) const
Derived &	derived ()
const Derived &	derived () const
Derived	inverse () const
RotationMatrixType	matrix () const
internal::rotation_base_generic_product_selector< Derived, OtherDerived, OtherDerived::IsVectorAtCompileTime >::ReturnType	operator* (const EigenBase< OtherDerived > &e) const
Transform< Scalar, Dim, Mode >	operator* (const Transform< Scalar, Dim, Mode, Options > &t) const
Transform< Scalar, Dim, Isometry >	operator* (const Translation< Scalar, Dim > &t) const
RotationMatrixType	operator* (const UniformScaling< Scalar > &s) const
RotationMatrixType	toRotationMatrix () const

Static Public Member Functions
static Vector3	AlphaAxisVector ()
static Vector3	BetaAxisVector ()
static Vector3	GammaAxisVector ()

Private Attributes
Vector3	m_angles

Additional Inherited Members
Public Attributes inherited from Eigen::RotationBase< EulerAngles< Scalar_, _System >, 3 >
	Dim

Detailed Description

template<typename Scalar_, class _System>
class Eigen::EulerAngles< Scalar_, _System >

Represents a rotation in a 3 dimensional space as three Euler angles.

Euler rotation is a set of three rotation of three angles over three fixed axes, defined by the EulerSystem given as a template parameter.

Here is how intrinsic Euler angles works:

• first, rotate the axes system over the alpha axis in angle alpha
• then, rotate the axes system over the beta axis(which was rotated in the first stage) in angle beta
• then, rotate the axes system over the gamma axis(which was rotated in the two stages above) in angle gamma

Note

This class support only intrinsic Euler angles for simplicity, see EulerSystem how to easily overcome this for extrinsic systems.

Rotation representation and conversions

It has been proved(see Wikipedia link below) that every rotation can be represented by Euler angles, but there is no single representation (e.g. unlike rotation matrices). Therefore, you can convert from Eigen rotation and to them (including rotation matrices, which is not called "rotations" by Eigen design).

Euler angles usually used for:

• convenient human representation of rotation, especially in interactive GUI.
• gimbal systems and robotics
• efficient encoding(i.e. 3 floats only) of rotation for network protocols.

However, Euler angles are slow comparing to quaternion or matrices, because their unnatural math definition, although it's simple for human. To overcome this, this class provide easy movement from the math friendly representation to the human friendly representation, and vise-versa.

All the user need to do is a safe simple C++ type conversion, and this class take care for the math. Additionally, some axes related computation is done in compile time.

Euler angles ranges in conversions

Rotations representation as EulerAngles are not single (unlike matrices), and even have infinite EulerAngles representations.
For example, add or subtract 2*PI from either angle of EulerAngles and you'll get the same rotation. This is the general reason for infinite representation, but it's not the only general reason for not having a single representation.

When converting rotation to EulerAngles, this class convert it to specific ranges When converting some rotation to EulerAngles, the rules for ranges are as follow:

• If the rotation we converting from is an EulerAngles (even when it represented as RotationBase explicitly), angles ranges are undefined.
• otherwise, alpha and gamma angles will be in the range [-PI, PI].
  As for Beta angle:
  • If the system is Tait-Bryan, the beta angle will be in the range [-PI/2, PI/2].
  • otherwise:
    • If the beta axis is positive, the beta angle will be in the range [0, PI]
    • If the beta axis is negative, the beta angle will be in the range [-PI, 0]

See also

EulerAngles(const MatrixBase<Derived>&)

EulerAngles(const RotationBase<Derived, 3>&)

Convenient user typedefs

Convenient typedefs for EulerAngles exist for float and double scalar, in a form of EulerAngles{A}{B}{C}{scalar}, e.g. EulerAnglesXYZd, EulerAnglesZYZf.

Only for positive axes{+x,+y,+z} Euler systems are have convenient typedef. If you need negative axes{-x,-y,-z}, it is recommended to create you own typedef with a word that represent what you need.

Example

#include <unsupported/Eigen/EulerAngles>
#include <iostream>
 
using namespace Eigen;
 
int main()
{
  // A common Euler system by many armies around the world,
  //  where the first one is the azimuth(the angle from the north -
  //   the same angle that is show in compass)
  //  and the second one is elevation(the angle from the horizon)
  //  and the third one is roll(the angle between the horizontal body
  //   direction and the plane ground surface)
  // Keep remembering we're using radian angles here!
  typedef EulerSystem<-EULER_Z, EULER_Y, EULER_X> MyArmySystem;
  typedef EulerAngles<double, MyArmySystem> MyArmyAngles;
  
  MyArmyAngles vehicleAngles(
    3.14/*PI*/ / 2, /* heading to east, notice that this angle is counter-clockwise */
    -0.3, /* going down from a mountain */
    0.1); /* slightly rolled to the right */
  
  // Some Euler angles representation that our plane use.
  EulerAnglesZYZd planeAngles(0.78474, 0.5271, -0.513794);
  
  MyArmyAngles planeAnglesInMyArmyAngles(planeAngles);
  
  std::cout << "vehicle angles(MyArmy):     " << vehicleAngles << std::endl;
  std::cout << "plane angles(ZYZ):        " << planeAngles << std::endl;
  std::cout << "plane angles(MyArmy):     " << planeAnglesInMyArmyAngles << std::endl;
  
  // Now lets rotate the plane a little bit
  std::cout << "==========================================================\n";
  std::cout << "rotating plane now!\n";
  std::cout << "==========================================================\n";
  
  Quaterniond planeRotated = AngleAxisd(-0.342, Vector3d::UnitY()) * planeAngles;
  
  planeAngles = planeRotated;
  planeAnglesInMyArmyAngles = planeRotated;
  
  std::cout << "new plane angles(ZYZ):     " << planeAngles << std::endl;
  std::cout << "new plane angles(MyArmy): " << planeAnglesInMyArmyAngles << std::endl;
  
  return 0;
}

Output:

vehicle angles(MyArmy):     1.57 -0.3  0.1
plane angles(ZYZ):          0.78474    0.5271 -0.513794
plane angles(MyArmy):     -0.206273  0.453463 -0.278617
==========================================================
rotating plane now!
==========================================================
new plane angles(ZYZ):      1.44358 0.366507 -1.23637
new plane angles(MyArmy):  -0.18648  0.117896 -0.347841

Additional reading

If you're want to get more idea about how Euler system work in Eigen see EulerSystem.

More information about Euler angles: https://en.wikipedia.org/wiki/Euler_angles

Template Parameters

Scalar_	the scalar type, i.e. the type of the angles.
_System	the EulerSystem to use, which represents the axes of rotation.

Definition at line 102 of file EulerAngles.h.

Member Typedef Documentation

AngleAxisType

template<typename Scalar_ , class _System >

typedef AngleAxis<Scalar> Eigen::EulerAngles< Scalar_, _System >::AngleAxisType

the equivalent angle-axis type

Definition at line 117 of file EulerAngles.h.

Base

template<typename Scalar_ , class _System >

typedef RotationBase<EulerAngles<Scalar_, _System>, 3> Eigen::EulerAngles< Scalar_, _System >::Base

Definition at line 105 of file EulerAngles.h.

Matrix3

template<typename Scalar_ , class _System >

typedef Matrix<Scalar,3,3> Eigen::EulerAngles< Scalar_, _System >::Matrix3

the equivalent rotation matrix type

Definition at line 114 of file EulerAngles.h.

QuaternionType

template<typename Scalar_ , class _System >

typedef Quaternion<Scalar> Eigen::EulerAngles< Scalar_, _System >::QuaternionType

the equivalent quaternion type

Definition at line 116 of file EulerAngles.h.

RealScalar

template<typename Scalar_ , class _System >

typedef NumTraits<Scalar>::Real Eigen::EulerAngles< Scalar_, _System >::RealScalar

Definition at line 109 of file EulerAngles.h.

Scalar

template<typename Scalar_ , class _System >

typedef Scalar_ Eigen::EulerAngles< Scalar_, _System >::Scalar

the scalar type of the angles

Definition at line 108 of file EulerAngles.h.

System

template<typename Scalar_ , class _System >

typedef _System Eigen::EulerAngles< Scalar_, _System >::System

the EulerSystem to use, which represents the axes of rotation.

Definition at line 112 of file EulerAngles.h.

Vector3

template<typename Scalar_ , class _System >

typedef Matrix<Scalar,3,1> Eigen::EulerAngles< Scalar_, _System >::Vector3

the equivalent 3 dimension vector type

Definition at line 115 of file EulerAngles.h.

Constructor & Destructor Documentation

EulerAngles() [1/5]

template<typename Scalar_ , class _System >

Eigen::EulerAngles< Scalar_, _System >::EulerAngles ( )

inline

Default constructor without initialization.

Definition at line 142 of file EulerAngles.h.

{}

EulerAngles() [2/5]

template<typename Scalar_ , class _System >

Eigen::EulerAngles< Scalar_, _System >::EulerAngles ( const Scalar &  alpha, const Scalar &  beta, const Scalar &  gamma  )

inline

Constructs and initialize an EulerAngles (alpha, beta, gamma).

Definition at line 144 of file EulerAngles.h.

                                                                                :
        m_angles(alpha, beta, gamma) {}

EulerAngles() [3/5]

template<typename Scalar_ , class _System >

Eigen::EulerAngles< Scalar_, _System >::EulerAngles ( const Scalar *  data )

inlineexplicit

Constructs and initialize an EulerAngles from the array data {alpha, beta, gamma}

Definition at line 149 of file EulerAngles.h.

: m_angles(data) {}

EulerAngles() [4/5]

template<typename Scalar_ , class _System >

template<typename Derived >

Eigen::EulerAngles< Scalar_, _System >::EulerAngles ( const MatrixBase< Derived > &  other )

inlineexplicit

Constructs and initializes an EulerAngles from either:

• a 3x3 rotation matrix expression(i.e. pure orthogonal matrix with determinant of +1),
• a 3D vector expression representing Euler angles.

Note

If other is a 3x3 rotation matrix, the angles range rules will be as follow:
Alpha and gamma angles will be in the range [-PI, PI].
As for Beta angle:

• If the system is Tait-Bryan, the beta angle will be in the range [-PI/2, PI/2].
• otherwise:
  • If the beta axis is positive, the beta angle will be in the range [0, PI]
  • If the beta axis is negative, the beta angle will be in the range [-PI, 0]

Definition at line 164 of file EulerAngles.h.

{ *this = other; }

EulerAngles() [5/5]

template<typename Scalar_ , class _System >

template<typename Derived >

Eigen::EulerAngles< Scalar_, _System >::EulerAngles ( const RotationBase< Derived, 3 > &  rot )

inline

Constructs and initialize Euler angles from a rotation rot.

Note

If rot is an EulerAngles (even when it represented as RotationBase explicitly), angles ranges are undefined. Otherwise, alpha and gamma angles will be in the range [-PI, PI].
As for Beta angle:

• If the system is Tait-Bryan, the beta angle will be in the range [-PI/2, PI/2].
• otherwise:
  • If the beta axis is positive, the beta angle will be in the range [0, PI]
  • If the beta axis is negative, the beta angle will be in the range [-PI, 0]

Definition at line 178 of file EulerAngles.h.

{ System::CalcEulerAngles(*this, rot.toRotationMatrix()); }

Member Function Documentation

alpha() [1/2]

template<typename Scalar_ , class _System >

Scalar& Eigen::EulerAngles< Scalar_, _System >::alpha ( )

inline

Returns

A read-write reference to the angle of the first angle.

Definition at line 202 of file EulerAngles.h.

{ return m_angles[0]; }

alpha() [2/2]

template<typename Scalar_ , class _System >

Scalar Eigen::EulerAngles< Scalar_, _System >::alpha ( ) const

inline

Returns

The value of the first angle.

Definition at line 200 of file EulerAngles.h.

{ return m_angles[0]; }

AlphaAxisVector()

template<typename Scalar_ , class _System >

static Vector3 Eigen::EulerAngles< Scalar_, _System >::AlphaAxisVector ( )

inlinestatic

Returns

the axis vector of the first (alpha) rotation

Definition at line 120 of file EulerAngles.h.

                                       {
        const Vector3& u = Vector3::Unit(System::AlphaAxisAbs - 1);
        return System::IsAlphaOpposite ? -u : u;
      }

angles() [1/2]

template<typename Scalar_ , class _System >

Vector3& Eigen::EulerAngles< Scalar_, _System >::angles ( )

inline

Returns

A read-write reference to the angle values stored in a vector (alpha, beta, gamma).

Definition at line 197 of file EulerAngles.h.

{ return m_angles; }

angles() [2/2]

template<typename Scalar_ , class _System >

const Vector3& Eigen::EulerAngles< Scalar_, _System >::angles ( ) const

inline

Returns

The angle values stored in a vector (alpha, beta, gamma).

Definition at line 195 of file EulerAngles.h.

{ return m_angles; }

beta() [1/2]

template<typename Scalar_ , class _System >

Scalar& Eigen::EulerAngles< Scalar_, _System >::beta ( )

inline

Returns

A read-write reference to the angle of the second angle.

Definition at line 207 of file EulerAngles.h.

{ return m_angles[1]; }

beta() [2/2]

template<typename Scalar_ , class _System >

Scalar Eigen::EulerAngles< Scalar_, _System >::beta ( ) const

inline

Returns

The value of the second angle.

Definition at line 205 of file EulerAngles.h.

{ return m_angles[1]; }

BetaAxisVector()

template<typename Scalar_ , class _System >

static Vector3 Eigen::EulerAngles< Scalar_, _System >::BetaAxisVector ( )

inlinestatic

Returns

the axis vector of the second (beta) rotation

Definition at line 126 of file EulerAngles.h.

                                      {
        const Vector3& u = Vector3::Unit(System::BetaAxisAbs - 1);
        return System::IsBetaOpposite ? -u : u;
      }

cast()

template<typename Scalar_ , class _System >

template<typename NewScalarType >

EulerAngles<NewScalarType, System> Eigen::EulerAngles< Scalar_, _System >::cast ( ) const

inline

Returns

*this with scalar type casted to NewScalarType

Definition at line 294 of file EulerAngles.h.

      {
        EulerAngles<NewScalarType, System> e;
        e.angles() = angles().template cast<NewScalarType>();
        return e;
      }

gamma() [1/2]

template<typename Scalar_ , class _System >

Scalar& Eigen::EulerAngles< Scalar_, _System >::gamma ( )

inline

Returns

A read-write reference to the angle of the third angle.

Definition at line 212 of file EulerAngles.h.

{ return m_angles[2]; }

gamma() [2/2]

template<typename Scalar_ , class _System >

Scalar Eigen::EulerAngles< Scalar_, _System >::gamma ( ) const

inline

Returns

The value of the third angle.

Definition at line 210 of file EulerAngles.h.

{ return m_angles[2]; }

GammaAxisVector()

template<typename Scalar_ , class _System >

static Vector3 Eigen::EulerAngles< Scalar_, _System >::GammaAxisVector ( )

inlinestatic

Returns

the axis vector of the third (gamma) rotation

Definition at line 132 of file EulerAngles.h.

                                       {
        const Vector3& u = Vector3::Unit(System::GammaAxisAbs - 1);
        return System::IsGammaOpposite ? -u : u;
      }

inverse()

template<typename Scalar_ , class _System >

EulerAngles Eigen::EulerAngles< Scalar_, _System >::inverse ( ) const

inline

Returns

The Euler angles rotation inverse (which is as same as the negative), (-alpha, -beta, -gamma).

Definition at line 217 of file EulerAngles.h.

      {
        EulerAngles res;
        res.m_angles = -m_angles;
        return res;
      }

isApprox()

template<typename Scalar_ , class _System >

bool Eigen::EulerAngles< Scalar_, _System >::isApprox ( const EulerAngles< Scalar_, _System > &  other, const RealScalar &  prec = NumTraits<Scalar>::dummy_precision()  ) const

inline

Returns

true if *this is approximately equal to other, within the precision determined by prec.

See also

MatrixBase::isApprox()

Definition at line 266 of file EulerAngles.h.

      { return angles().isApprox(other.angles(), prec); }

operator QuaternionType()

template<typename Scalar_ , class _System >

Eigen::EulerAngles< Scalar_, _System >::operator QuaternionType ( ) const

inline

Convert the Euler angles to quaternion.

Definition at line 278 of file EulerAngles.h.

      {
        return
          AngleAxisType(alpha(), AlphaAxisVector()) *
          AngleAxisType(beta(), BetaAxisVector())   *
          AngleAxisType(gamma(), GammaAxisVector());
      }

operator-()

template<typename Scalar_ , class _System >

EulerAngles Eigen::EulerAngles< Scalar_, _System >::operator- ( ) const

inline

Returns

The Euler angles rotation negative (which is as same as the inverse), (-alpha, -beta, -gamma).

Definition at line 227 of file EulerAngles.h.

      {
        return inverse();
      }

operator=() [1/2]

template<typename Scalar_ , class _System >

template<class Derived >

EulerAngles& Eigen::EulerAngles< Scalar_, _System >::operator= ( const MatrixBase< Derived > &  other )

inline

Set *this from either:

• a 3x3 rotation matrix expression(i.e. pure orthogonal matrix with determinant of +1),
• a 3D vector expression representing Euler angles.

See EulerAngles(const MatrixBase<Derived, 3>&) for more information about angles ranges output.

Definition at line 240 of file EulerAngles.h.

      {
        EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename Derived::Scalar>::value),
         YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
        
        internal::eulerangles_assign_impl<System, Derived>::run(*this, other.derived());
        return *this;
      }

operator=() [2/2]

template<typename Scalar_ , class _System >

template<typename Derived >

EulerAngles& Eigen::EulerAngles< Scalar_, _System >::operator= ( const RotationBase< Derived, 3 > &  rot )

inline

Set *this from a rotation.

See EulerAngles(const RotationBase<Derived, 3>&) for more information about angles ranges output.

Definition at line 257 of file EulerAngles.h.

                                                                  {
        System::CalcEulerAngles(*this, rot.toRotationMatrix());
        return *this;
      }

toRotationMatrix()

template<typename Scalar_ , class _System >

Matrix3 Eigen::EulerAngles< Scalar_, _System >::toRotationMatrix ( ) const

inline

Returns

an equivalent 3x3 rotation matrix.

Definition at line 271 of file EulerAngles.h.

      {
        // TODO: Calc it faster
        return static_cast<QuaternionType>(*this).toRotationMatrix();
      }

Member Data Documentation

m_angles

template<typename Scalar_ , class _System >

Vector3 Eigen::EulerAngles< Scalar_, _System >::m_angles

private

Definition at line 138 of file EulerAngles.h.

---

The documentation for this class was generated from the following file:

• EulerAngles.h