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

#include <EulerAngles.h>

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

Public Types
typedef AngleAxis< Scalar >	AngleAxisType

typedef Matrix< Scalar, 3, 3 >	Matrix3

typedef Quaternion< Scalar >	QuaternionType

typedef _Scalar	Scalar

typedef _System	System

typedef Matrix< Scalar, 3, 1 >	Vector3

Public Types inherited from Eigen::RotationBase< EulerAngles< _Scalar, _System >, 3 >
enum

typedef Matrix< Scalar, Dim, Dim >	RotationMatrixType

typedef internal::traits< EulerAngles< _Scalar, _System > >::Scalar	Scalar

typedef Matrix< Scalar, Dim, 1 >	VectorType

Public Member Functions
Scalar	alpha () const

Scalar &	alpha ()

const Vector3 &	angles () const

Vector3 &	angles ()

Scalar	beta () const

Scalar &	beta ()

	EulerAngles ()

	EulerAngles (const Scalar &alpha, const Scalar &beta, const Scalar &gamma)

template<typename Derived >
	EulerAngles (const MatrixBase< Derived > &m)

template<typename Derived >
	EulerAngles (const MatrixBase< Derived > &m, bool positiveRangeAlpha, bool positiveRangeBeta, bool positiveRangeGamma)

template<typename Derived >
	EulerAngles (const RotationBase< Derived, 3 > &rot)

template<typename Derived >
	EulerAngles (const RotationBase< Derived, 3 > &rot, bool positiveRangeAlpha, bool positiveRangeBeta, bool positiveRangeGamma)

Scalar	gamma () const

Scalar &	gamma ()

EulerAngles	inverse () const

	operator QuaternionType () const

EulerAngles	operator- () const

template<typename Derived >
EulerAngles &	operator= (const MatrixBase< Derived > &m)

template<typename Derived >
EulerAngles &	operator= (const RotationBase< Derived, 3 > &rot)

Matrix3	toRotationMatrix () const

Public Member Functions inherited from Eigen::RotationBase< EulerAngles< _Scalar, _System >, 3 >
EIGEN_DEVICE_FUNC VectorType	_transformVector (const OtherVectorType &v) const

EIGEN_DEVICE_FUNC const EulerAngles< _Scalar, _System > &	derived () const

EIGEN_DEVICE_FUNC EulerAngles< _Scalar, _System > &	derived ()

EIGEN_DEVICE_FUNC EulerAngles< _Scalar, _System >	inverse () const

EIGEN_DEVICE_FUNC RotationMatrixType	matrix () const

EIGEN_DEVICE_FUNC Transform< Scalar, Dim, Isometry >	operator* (const Translation< Scalar, Dim > &t) const

EIGEN_DEVICE_FUNC RotationMatrixType	operator* (const UniformScaling< Scalar > &s) const

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::rotation_base_generic_product_selector< EulerAngles< _Scalar, _System >, OtherDerived, OtherDerived::IsVectorAtCompileTime >::ReturnType	operator* (const EigenBase< OtherDerived > &e) const

EIGEN_DEVICE_FUNC Transform< Scalar, Dim, Mode >	operator* (const Transform< Scalar, Dim, Mode, Options > &t) const

EIGEN_DEVICE_FUNC RotationMatrixType	toRotationMatrix () const

Static Public Member Functions
static Vector3	AlphaAxisVector ()

static Vector3	BetaAxisVector ()

template<bool PositiveRangeAlpha, bool PositiveRangeBeta, bool PositiveRangeGamma, typename Derived >
static EulerAngles	FromRotation (const MatrixBase< Derived > &m)

template<bool PositiveRangeAlpha, bool PositiveRangeBeta, bool PositiveRangeGamma, typename Derived >
static EulerAngles	FromRotation (const RotationBase< Derived, 3 > &rot)

static Vector3	GammaAxisVector ()

Private Attributes
Vector3	m_angles

Friends
std::ostream &	operator<< (std::ostream &s, const EulerAngles< Scalar, System > &eulerAngles)

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

When converting some rotation to Euler angles, there are some ways you can guarantee the Euler angles ranges.

implicit ranges

When using implicit ranges, all angles are guarantee to be in the range [-PI, +PI], unless you convert from some other Euler angles. In this case, the range is undefined (might be even less than -PI or greater than +2*PI).

See also: EulerAngles(const MatrixBase<Derived>&); EulerAngles(const RotationBase<Derived, 3>&)

explicit ranges

When using explicit ranges, all angles are guarantee to be in the range you choose. In the range Boolean parameter, you're been ask whether you prefer the positive range or not:

true - force the range between [0, +2*PI]
false - force the range between [-PI, +PI]

compile time ranges

This is when you have compile time ranges and you prefer to use template parameter. (e.g. for performance)

See also: FromRotation()

run-time time ranges

Run-time ranges are also supported.

See also: EulerAngles(const MatrixBase<Derived>&, bool, bool, bool); EulerAngles(const RotationBase<Derived, 3>&, bool, bool, bool)

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

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2015 Tal Hadad <tal_hd@hotmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include "main.h"
#include <unsupported/Eigen/EulerAngles>
using namespace Eigen;
template<typename EulerSystem, typename Scalar>
void verify_euler_ranged(const Matrix<Scalar,3,1>& ea,
  bool positiveRangeAlpha, bool positiveRangeBeta, bool positiveRangeGamma)
{
  typedef EulerAngles<Scalar, EulerSystem> EulerAnglesType;
  typedef Matrix<Scalar,3,3> Matrix3;
  typedef Matrix<Scalar,3,1> Vector3;
  typedef Quaternion<Scalar> QuaternionType;
  typedef AngleAxis<Scalar> AngleAxisType;
  using std::abs;
  
  Scalar alphaRangeStart, alphaRangeEnd;
  Scalar betaRangeStart, betaRangeEnd;
  Scalar gammaRangeStart, gammaRangeEnd;
  
  if (positiveRangeAlpha)
  {
    alphaRangeStart = Scalar(0);
    alphaRangeEnd = Scalar(2 * EIGEN_PI);
  }
  else
  {
    alphaRangeStart = -Scalar(EIGEN_PI);
    alphaRangeEnd = Scalar(EIGEN_PI);
  }
  
  if (positiveRangeBeta)
  {
    betaRangeStart = Scalar(0);
    betaRangeEnd = Scalar(2 * EIGEN_PI);
  }
  else
  {
    betaRangeStart = -Scalar(EIGEN_PI);
    betaRangeEnd = Scalar(EIGEN_PI);
  }
  
  if (positiveRangeGamma)
  {
    gammaRangeStart = Scalar(0);
    gammaRangeEnd = Scalar(2 * EIGEN_PI);
  }
  else
  {
    gammaRangeStart = -Scalar(EIGEN_PI);
    gammaRangeEnd = Scalar(EIGEN_PI);
  }
  
  const int i = EulerSystem::AlphaAxisAbs - 1;
  const int j = EulerSystem::BetaAxisAbs - 1;
  const int k = EulerSystem::GammaAxisAbs - 1;
  
  const int iFactor = EulerSystem::IsAlphaOpposite ? -1 : 1;
  const int jFactor = EulerSystem::IsBetaOpposite ? -1 : 1;
  const int kFactor = EulerSystem::IsGammaOpposite ? -1 : 1;
  
  const Vector3 I = EulerAnglesType::AlphaAxisVector();
  const Vector3 J = EulerAnglesType::BetaAxisVector();
  const Vector3 K = EulerAnglesType::GammaAxisVector();
  
  EulerAnglesType e(ea[0], ea[1], ea[2]);
  
  Matrix3 m(e);
  Vector3 eabis = EulerAnglesType(m, positiveRangeAlpha, positiveRangeBeta, positiveRangeGamma).angles();
  
  // Check that eabis in range
  VERIFY(alphaRangeStart <= eabis[0] && eabis[0] <= alphaRangeEnd);
  VERIFY(betaRangeStart <= eabis[1] && eabis[1] <= betaRangeEnd);
  VERIFY(gammaRangeStart <= eabis[2] && eabis[2] <= gammaRangeEnd);
  
  Vector3 eabis2 = m.eulerAngles(i, j, k);
  
  // Invert the relevant axes
  eabis2[0] *= iFactor;
  eabis2[1] *= jFactor;
  eabis2[2] *= kFactor;
  
  // Saturate the angles to the correct range
  if (positiveRangeAlpha && (eabis2[0] < 0))
    eabis2[0] += Scalar(2 * EIGEN_PI);
  if (positiveRangeBeta && (eabis2[1] < 0))
    eabis2[1] += Scalar(2 * EIGEN_PI);
  if (positiveRangeGamma && (eabis2[2] < 0))
    eabis2[2] += Scalar(2 * EIGEN_PI);
  
  VERIFY_IS_APPROX(eabis, eabis2);// Verify that our estimation is the same as m.eulerAngles() is
  
  Matrix3 mbis(AngleAxisType(eabis[0], I) * AngleAxisType(eabis[1], J) * AngleAxisType(eabis[2], K));
  VERIFY_IS_APPROX(m,  mbis);
  
  // Tests that are only relevant for no possitive range
  if (!(positiveRangeAlpha || positiveRangeBeta || positiveRangeGamma))
  {
    /* If I==K, and ea[1]==0, then there no unique solution. */ 
    /* The remark apply in the case where I!=K, and |ea[1]| is close to pi/2. */ 
    if( (i!=k || ea[1]!=0) && (i==k || !internal::isApprox(abs(ea[1]),Scalar(EIGEN_PI/2),test_precision<Scalar>())) ) 
      VERIFY((ea-eabis).norm() <= test_precision<Scalar>());
    
    // approx_or_less_than does not work for 0
    VERIFY(0 < eabis[0] || test_isMuchSmallerThan(eabis[0], Scalar(1)));
  }
  
  // Quaternions
  QuaternionType q(e);
  eabis = EulerAnglesType(q, positiveRangeAlpha, positiveRangeBeta, positiveRangeGamma).angles();
  VERIFY_IS_APPROX(eabis, eabis2);// Verify that the euler angles are still the same
}
template<typename EulerSystem, typename Scalar>
void verify_euler(const Matrix<Scalar,3,1>& ea)
{
  verify_euler_ranged<EulerSystem>(ea, false, false, false);
  verify_euler_ranged<EulerSystem>(ea, false, false, true);
  verify_euler_ranged<EulerSystem>(ea, false, true, false);
  verify_euler_ranged<EulerSystem>(ea, false, true, true);
  verify_euler_ranged<EulerSystem>(ea, true, false, false);
  verify_euler_ranged<EulerSystem>(ea, true, false, true);
  verify_euler_ranged<EulerSystem>(ea, true, true, false);
  verify_euler_ranged<EulerSystem>(ea, true, true, true);
}
template<typename Scalar> void check_all_var(const Matrix<Scalar,3,1>& ea)
{
  verify_euler<EulerSystemXYZ>(ea);
  verify_euler<EulerSystemXYX>(ea);
  verify_euler<EulerSystemXZY>(ea);
  verify_euler<EulerSystemXZX>(ea);
  
  verify_euler<EulerSystemYZX>(ea);
  verify_euler<EulerSystemYZY>(ea);
  verify_euler<EulerSystemYXZ>(ea);
  verify_euler<EulerSystemYXY>(ea);
  
  verify_euler<EulerSystemZXY>(ea);
  verify_euler<EulerSystemZXZ>(ea);
  verify_euler<EulerSystemZYX>(ea);
  verify_euler<EulerSystemZYZ>(ea);
}
template<typename Scalar> void eulerangles()
{
  typedef Matrix<Scalar,3,3> Matrix3;
  typedef Matrix<Scalar,3,1> Vector3;
  typedef Array<Scalar,3,1> Array3;
  typedef Quaternion<Scalar> Quaternionx;
  typedef AngleAxis<Scalar> AngleAxisType;
  Scalar a = internal::random<Scalar>(-Scalar(EIGEN_PI), Scalar(EIGEN_PI));
  Quaternionx q1;
  q1 = AngleAxisType(a, Vector3::Random().normalized());
  Matrix3 m;
  m = q1;
  
  Vector3 ea = m.eulerAngles(0,1,2);
  check_all_var(ea);
  ea = m.eulerAngles(0,1,0);
  check_all_var(ea);
  
  // Check with purely random Quaternion:
  q1.coeffs() = Quaternionx::Coefficients::Random().normalized();
  m = q1;
  ea = m.eulerAngles(0,1,2);
  check_all_var(ea);
  ea = m.eulerAngles(0,1,0);
  check_all_var(ea);
  
  // Check with random angles in range [0:pi]x[-pi:pi]x[-pi:pi].
  ea = (Array3::Random() + Array3(1,0,0))*Scalar(EIGEN_PI)*Array3(0.5,1,1);
  check_all_var(ea);
  
  ea[2] = ea[0] = internal::random<Scalar>(0,Scalar(EIGEN_PI));
  check_all_var(ea);
  
  ea[0] = ea[1] = internal::random<Scalar>(0,Scalar(EIGEN_PI));
  check_all_var(ea);
  
  ea[1] = 0;
  check_all_var(ea);
  
  ea.head(2).setZero();
  check_all_var(ea);
  
  ea.setZero();
  check_all_var(ea);
}
void test_EulerAngles()
{
  for(int i = 0; i < g_repeat; i++) {
    CALL_SUBTEST_1( eulerangles<float>() );
    CALL_SUBTEST_2( eulerangles<double>() );
  }
}

Output:

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 111 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

Member Typedef Documentation

template<typename _Scalar, class _System>

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

the equivalent angle-axis type

Definition at line 123 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

template<typename _Scalar, class _System>

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

the equivalent rotation matrix type

Definition at line 120 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

template<typename _Scalar, class _System>

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

the equivalent quaternion type

Definition at line 122 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

template<typename _Scalar, class _System>

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

the scalar type of the angles

Definition at line 115 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

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 118 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

template<typename _Scalar, class _System>

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

the equivalent 3 dimension vector type

Definition at line 121 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

Constructor & Destructor Documentation

template<typename _Scalar, class _System>

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

inline

Default constructor without initialization.

Definition at line 148 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

template<typename _Scalar, class _System>

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

inline

Constructs and initialize Euler angles(alpha, beta, gamma).

Definition at line 150 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

template<typename _Scalar, class _System>

template<typename Derived >

Eigen::EulerAngles< _Scalar, _System >::EulerAngles ( const MatrixBase< Derived > & m )

inline

Constructs and initialize Euler angles from a 3x3 rotation matrix m.

Note: All angles will be in the range [-PI, PI].

Definition at line 158 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

template<typename _Scalar, class _System>

template<typename Derived >

Eigen::EulerAngles< _Scalar, _System >::EulerAngles	(	const MatrixBase< Derived > &	m,
		bool	positiveRangeAlpha,
		bool	positiveRangeBeta,
		bool	positiveRangeGamma
	)

inline

Constructs and initialize Euler angles from a 3x3 rotation matrix m, with options to choose for each angle the requested range.

If positive range is true, then the specified angle will be in the range [0, +2*PI]. Otherwise, the specified angle will be in the range [-PI, +PI].

Parameters

m	The 3x3 rotation matrix to convert
positiveRangeAlpha	If true, alpha will be in [0, 2*PI]. Otherwise, in [-PI, +PI].
positiveRangeBeta	If true, beta will be in [0, 2*PI]. Otherwise, in [-PI, +PI].
positiveRangeGamma	If true, gamma will be in [0, 2*PI]. Otherwise, in [-PI, +PI].

Definition at line 172 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

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: All angles will be in the range [-PI, PI], unless rot is an EulerAngles. If rot is an EulerAngles, expected EulerAngles range is undefined. (Use other functions here for enforcing range if this effect is desired)

Definition at line 188 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

template<typename _Scalar, class _System>

template<typename Derived >

Eigen::EulerAngles< _Scalar, _System >::EulerAngles	(	const RotationBase< Derived, 3 > &	rot,
		bool	positiveRangeAlpha,
		bool	positiveRangeBeta,
		bool	positiveRangeGamma
	)

inline

Constructs and initialize Euler angles from a rotation rot, with options to choose for each angle the requested range.

If positive range is true, then the specified angle will be in the range [0, +2*PI]. Otherwise, the specified angle will be in the range [-PI, +PI].

Parameters

rot	The 3x3 rotation matrix to convert
positiveRangeAlpha	If true, alpha will be in [0, 2*PI]. Otherwise, in [-PI, +PI].
positiveRangeBeta	If true, beta will be in [0, 2*PI]. Otherwise, in [-PI, +PI].
positiveRangeGamma	If true, gamma will be in [0, 2*PI]. Otherwise, in [-PI, +PI].

Definition at line 202 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

Member Function Documentation

template<typename _Scalar, class _System>

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

inline

Returns: The value of the first angle.

Definition at line 217 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

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 219 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

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 126 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

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 212 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

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 214 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

template<typename _Scalar, class _System>

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

inline

Returns: The value of the second angle.

Definition at line 222 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

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 224 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

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 132 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

template<typename _Scalar, class _System>

template<bool PositiveRangeAlpha, bool PositiveRangeBeta, bool PositiveRangeGamma, typename Derived >

static EulerAngles Eigen::EulerAngles< _Scalar, _System >::FromRotation ( const MatrixBase< Derived > & m )

inlinestatic

Constructs and initialize Euler angles from a 3x3 rotation matrix m, with options to choose for each angle the requested range (only in compile time).

If positive range is true, then the specified angle will be in the range [0, +2*PI]. Otherwise, the specified angle will be in the range [-PI, +PI].

Parameters

m	The 3x3 rotation matrix to convert

Template Parameters

positiveRangeAlpha	If true, alpha will be in [0, 2*PI]. Otherwise, in [-PI, +PI].
positiveRangeBeta	If true, beta will be in [0, 2*PI]. Otherwise, in [-PI, +PI].
positiveRangeGamma	If true, gamma will be in [0, 2*PI]. Otherwise, in [-PI, +PI].

Definition at line 265 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

template<typename _Scalar, class _System>

template<bool PositiveRangeAlpha, bool PositiveRangeBeta, bool PositiveRangeGamma, typename Derived >

static EulerAngles Eigen::EulerAngles< _Scalar, _System >::FromRotation ( const RotationBase< Derived, 3 > & rot )

inlinestatic

Constructs and initialize Euler angles from a rotation rot, with options to choose for each angle the requested range (only in compile time).

If positive range is true, then the specified angle will be in the range [0, +2*PI]. Otherwise, the specified angle will be in the range [-PI, +PI].

Parameters

rot	The 3x3 rotation matrix to convert

Template Parameters

positiveRangeAlpha	If true, alpha will be in [0, 2*PI]. Otherwise, in [-PI, +PI].
positiveRangeBeta	If true, beta will be in [0, 2*PI]. Otherwise, in [-PI, +PI].
positiveRangeGamma	If true, gamma will be in [0, 2*PI]. Otherwise, in [-PI, +PI].

Definition at line 291 of file unsupported/Eigen/src/EulerAngles/EulerAngles.h.

template<typename _Scalar, class _System>

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

inline