|
| | EulerAngles () |
| |
| | EulerAngles (const Scalar &alpha, const Scalar &beta, const Scalar &gamma) |
| |
| | EulerAngles (const Scalar *data) |
| |
| template<typename Derived > |
| | EulerAngles (const MatrixBase< Derived > &other) |
| |
| template<typename Derived > |
| | EulerAngles (const RotationBase< Derived, 3 > &rot) |
| |
| 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<class Derived > |
| EulerAngles & | operator= (const MatrixBase< Derived > &other) |
| |
| template<typename Derived > |
| EulerAngles & | operator= (const RotationBase< Derived, 3 > &rot) |
| |
| bool | isApprox (const EulerAngles &other, const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const |
| |
| Matrix3 | toRotationMatrix () const |
| |
| | operator QuaternionType () const |
| |
| template<typename NewScalarType > |
| EulerAngles< NewScalarType, System > | cast () const |
| |
| 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 |
| |
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
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. |
Public Types inherited from Eigen::RotationBase< EulerAngles< _Scalar, _System >, 3 >