Represents a rotation in a 3 dimensional space as three Euler angles. More...
#include <EulerAngles.h>
Public Types | |
| typedef _Scalar | Scalar |
| the scalar type of the angles | |
| typedef _System | System |
| the EulerSystem to use, which represents the axes of rotation. More... | |
| typedef Matrix< Scalar, 3, 3 > | Matrix3 |
| typedef Matrix< Scalar, 3, 1 > | Vector3 |
| typedef Quaternion< Scalar > | QuaternionType |
| typedef AngleAxis< Scalar > | AngleAxisType |
 Public Types inherited from Eigen::RotationBase< EulerAngles< _Scalar, _System >, 3 > | |
| enum | |
| typedef internal::traits< EulerAngles< _Scalar, _System > >::Scalar | Scalar |
| the scalar type of the coefficients | |
| typedef Matrix< Scalar, Dim, Dim > | RotationMatrixType |
| corresponding linear transformation matrix type | |
| typedef Matrix< Scalar, Dim, 1 > | VectorType |
Public Member Functions | |
| EulerAngles () | |
| Default constructor without initialization. More... | |
| EulerAngles (const Scalar &alpha, const Scalar &beta, const Scalar &gamma) | |
Constructs and initialize Euler angles(alpha, beta, gamma). More... | |
| template<typename Derived > | |
| EulerAngles (const MatrixBase< Derived > &m) | |
Constructs and initialize Euler angles from a 3x3 rotation matrix m. More... | |
| template<typename Derived > | |
| EulerAngles (const MatrixBase< Derived > &m, bool positiveRangeAlpha, bool positiveRangeBeta, bool positiveRangeGamma) | |
Constructs and initialize Euler angles from a 3x3 rotation matrix m, with options to choose for each angle the requested range. More... | |
| template<typename Derived > | |
| EulerAngles (const RotationBase< Derived, 3 > &rot) | |
Constructs and initialize Euler angles from a rotation rot. More... | |
| template<typename Derived > | |
| EulerAngles (const RotationBase< Derived, 3 > &rot, bool positiveRangeAlpha, bool positiveRangeBeta, bool positiveRangeGamma) | |
Constructs and initialize Euler angles from a rotation rot, with options to choose for each angle the requested range. More... | |
| const Vector3 & | angles () const |
| Vector3 & | angles () |
| Scalar | alpha () const |
| Scalar & | alpha () |
| Scalar | beta () const |
| Scalar & | beta () |
| Scalar | gamma () const |
| Scalar & | gamma () |
| EulerAngles | inverse () const |
| EulerAngles | operator- () const |
| template<typename Derived > | |
| EulerAngles & | operator= (const MatrixBase< Derived > &m) |
Set *this from a rotation matrix(i.e. More... | |
| template<typename Derived > | |
| EulerAngles & | operator= (const RotationBase< Derived, 3 > &rot) |
Set *this from a rotation. More... | |
| Matrix3 | toRotationMatrix () const |
| operator QuaternionType () const | |
| Convert the Euler angles to quaternion. More... | |
| Public Member Functions inherited from Eigen::RotationBase< EulerAngles< _Scalar, _System >, 3 > | |
| EIGEN_DEVICE_FUNC const EulerAngles< _Scalar, _System > & | derived () const |
| EIGEN_DEVICE_FUNC EulerAngles< _Scalar, _System > & | derived () |
| EIGEN_DEVICE_FUNC RotationMatrixType | toRotationMatrix () const |
| EIGEN_DEVICE_FUNC RotationMatrixType | matrix () const |
| EIGEN_DEVICE_FUNC EulerAngles< _Scalar, _System > | inverse () 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 VectorType | _transformVector (const OtherVectorType &v) const |
Static Public Member Functions | |
| static Vector3 | AlphaAxisVector () |
| static Vector3 | BetaAxisVector () |
| static Vector3 | GammaAxisVector () |
| template<bool PositiveRangeAlpha, bool PositiveRangeBeta, bool PositiveRangeGamma, typename Derived > | |
| static EulerAngles | FromRotation (const MatrixBase< Derived > &m) |
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). More... | |
| template<bool PositiveRangeAlpha, bool PositiveRangeBeta, bool PositiveRangeGamma, typename Derived > | |
| static EulerAngles | FromRotation (const RotationBase< Derived, 3 > &rot) |
Constructs and initialize Euler angles from a rotation rot, with options to choose for each angle the requested range (only in compile time). More... | |
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).
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
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.
Member Typedef Documentation
§ AngleAxisType
| typedef AngleAxis<Scalar> Eigen::EulerAngles< _Scalar, _System >::AngleAxisType |
the equivalent angle-axis type
§ Matrix3
| typedef Matrix<Scalar,3,3> Eigen::EulerAngles< _Scalar, _System >::Matrix3 |
the equivalent rotation matrix type
§ QuaternionType
| typedef Quaternion<Scalar> Eigen::EulerAngles< _Scalar, _System >::QuaternionType |
the equivalent quaternion type
§ System
| typedef _System Eigen::EulerAngles< _Scalar, _System >::System |
the EulerSystem to use, which represents the axes of rotation.
§ Vector3
| typedef Matrix<Scalar,3,1> Eigen::EulerAngles< _Scalar, _System >::Vector3 |
the equivalent 3 dimension vector type
Constructor & Destructor Documentation
§ EulerAngles() [1/6]
|
inline |
Default constructor without initialization.
§ EulerAngles() [2/6]
|
inline |
Constructs and initialize Euler angles(alpha, beta, gamma).
§ EulerAngles() [3/6]
|
inline |
Constructs and initialize Euler angles from a 3x3 rotation matrix m.
- Note
- All angles will be in the range [-PI, PI].
§ EulerAngles() [4/6]
|
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].
§ EulerAngles() [5/6]
|
inline |
Constructs and initialize Euler angles from a rotation rot.
- Note
- All angles will be in the range [-PI, PI], unless
rotis an EulerAngles. If rot is an EulerAngles, expected EulerAngles range is undefined. (Use other functions here for enforcing range if this effect is desired)
§ EulerAngles() [6/6]
|
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].
Member Function Documentation
§ alpha() [1/2]
|
inline |
- Returns
- The value of the first angle.
§ alpha() [2/2]
|
inline |
- Returns
- A read-write reference to the angle of the first angle.
§ AlphaAxisVector()
|
inlinestatic |
- Returns
- the axis vector of the first (alpha) rotation
§ angles() [1/2]
|
inline |
- Returns
- The angle values stored in a vector (alpha, beta, gamma).
§ angles() [2/2]
|
inline |
- Returns
- A read-write reference to the angle values stored in a vector (alpha, beta, gamma).
§ beta() [1/2]
|
inline |
- Returns
- The value of the second angle.
§ beta() [2/2]
|
inline |
- Returns
- A read-write reference to the angle of the second angle.
§ BetaAxisVector()
|
inlinestatic |
- Returns
- the axis vector of the second (beta) rotation
§ FromRotation() [1/2]
|
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].
§ FromRotation() [2/2]
|
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].
§ gamma() [1/2]
|
inline |
- Returns
- The value of the third angle.
§ gamma() [2/2]
|
inline |
- Returns
- A read-write reference to the angle of the third angle.
§ GammaAxisVector()
|
inlinestatic |
- Returns
- the axis vector of the third (gamma) rotation
§ inverse()
|
inline |
- Returns
- The Euler angles rotation inverse (which is as same as the negative), (-alpha, -beta, -gamma).
§ operator QuaternionType()
|
inline |
Convert the Euler angles to quaternion.
§ operator-()
|
inline |
- Returns
- The Euler angles rotation negative (which is as same as the inverse), (-alpha, -beta, -gamma).
§ operator=() [1/2]
|
inline |
Set *this from a rotation matrix(i.e.
pure orthogonal matrix with determinant of +1).
§ operator=() [2/2]
|
inline |
Set *this from a rotation.
§ toRotationMatrix()
|
inline |
- Returns
- an equivalent 3x3 rotation matrix.
The documentation for this class was generated from the following file:
- third-party-libs/eigen3/unsupported/Eigen/src/EulerAngles/EulerAngles.h
