Euler¶
#include <Imath/ImathEuler.h>
The Euler class template represents an euler angle rotation/orientation,
with predefined typedefs of type float and double.
The Euler class is derived from Imath::Vec3 and thus has
fields named x, y, and z, which correspond to the first,
second, and third rotation angles in a specified order, which,
depending on the order, may not correspond directly to x, y, or z
rotations.
Example:
#include <Imath/ImathEuler.h>
#include <Imath/ImathMatrixAlgo.h>
#include <cassert>
void
euler_example ()
{
int i, j, k;
Imath::Eulerf xyz (Imath::Eulerf::XYZ);
xyz.angleOrder (i, j, k);
assert (i == 0 && j == 1 && k == 2);
Imath::Eulerf xzy (Imath::Eulerf::XZY);
xzy.angleOrder (i, j, k);
assert (i == 0 && j == 2 && k == 1);
Imath::Eulerf e1 (0.0f, 0.0f, 0.1f + 2 * M_PI);
Imath::Eulerf e2 (0.0f, 0.0f, 0.1f);
e1.makeNear (e2);
Imath::V3f v = e2.toXYZVector ();
assert (v.equalWithAbsError (Imath::V3f (0.0f, 0.0f, 0.1f), 0.00001f));
}
-
template<class T>
class Euler : public Imath::Vec3<T>¶ Template class
Euler<T>The Euler class represents euler angle orientations. The class inherits from Vec3 to it can be freely cast. The additional information is the euler priorities rep. This class is essentially a rip off of Ken Shoemake’s GemsIV code. It has been modified minimally to make it more understandable, but hardly enough to make it easy to grok completely.
There are 24 possible combonations of Euler angle representations of which 12 are common in CG and you will probably only use 6 of these which in this scheme are the non-relative-non-repeating types.
The representations can be partitioned according to two criteria:
1) Are the angles measured relative to a set of fixed axis or relative to each other (the latter being what happens when rotation matrices are multiplied together and is almost ubiquitous in the cg community)
2) Is one of the rotations repeated (ala XYX rotation)
When you construct a given representation from scratch you must order the angles according to their priorities. So, the easiest is a softimage or aerospace (yaw/pitch/roll) ordering of ZYX.
or:float x_rot = 1; float y_rot = 2; float z_rot = 3; Eulerf angles(z_rot, y_rot, x_rot, Eulerf::ZYX);
Eulerf angles( V3f(z_rot,y_rot,z_rot), Eulerf::ZYX );
If instead, the order was YXZ for instance you would have to do this:
or:float x_rot = 1; float y_rot = 2; float z_rot = 3; Eulerf angles(y_rot, x_rot, z_rot, Eulerf::YXZ);
Notice how the order you put the angles into the three slots should correspond to the enum (YXZ) ordering. The input angle vector is called the “ijk” vector — not an “xyz” vector. The ijk vector order is the same as the enum. If you treat the Euler as a Vec3 (which it inherts from) you will find the angles are ordered in the same way, i.e.:Eulerf angles( V3f(y_rot,x_rot,z_rot), Eulerf::YXZ );
If you just want the x, y, and z angles stored in a vector in that order, you can do this:V3f v = angles; v.x == y_rot, v.y == x_rot, v.z == z_rot
If you want to set the Euler with an XYZVector use the optional layout argument:V3f v = angles.toXYZVector() v.x == x_rot, v.y == y_rot, v.z == z_rot
This is the same as:Eulerf angles(x_rot, y_rot, z_rot, Eulerf::YXZ, Eulerf::XYZLayout);
Note that this won’t do anything intelligent if you have a repeated axis in the euler angles (e.g. XYX)Eulerf angles(y_rot, x_rot, z_rot, Eulerf::YXZ);
If you need to use the “relative” versions of these, you will need to use the “r” enums.
The units of the rotation angles are assumed to be radians.
Constructors
All default to
ZYXnon-relative (ala Softimage 3D/Maya), where there is no argument to specify it.The Euler-from-matrix constructors assume that the matrix does not include shear or non-uniform scaling, but the constructors do not examine the matrix to verify this assumption. If necessary, you can adjust the matrix by calling the removeScalingAndShear() function, defined in ImathMatrixAlgo.h.
-
constexpr Euler() noexcept¶
No initialization by default.
-
constexpr Euler(const Vec3<T> &v, Order o = Default, InputLayout l = IJKLayout) noexcept¶
Construct from vector, order, layout.
-
constexpr Euler(T i, T j, T k, Order o = Default, InputLayout l = IJKLayout) noexcept¶
Construct from explicit axes, order, layout.
-
~Euler() = default¶
Destructor.
Query
-
inline constexpr bool frameStatic() const¶
Return frameStatic.
-
inline constexpr bool initialRepeated() const¶
Return intialRepeated.
-
inline constexpr bool parityEven() const¶
Return partityEven.
-
void angleOrder(int &i, int &j, int &k) const noexcept¶
Unpack angles from ijk form.
-
void angleMapping(int &i, int &j, int &k) const noexcept¶
Determine mapping from xyz to ijk (reshuffle the xyz to match the order)
Set Value
-
void setOrder(Order) noexcept¶
Set the order.
This does NOT convert the angles, but it does reorder the input vector.
Assignments and Conversions
Utility Methods
Utility methods for getting continuous rotations. None of these methods change the orientation given by its inputs (or at least that is the intent).
-
void makeNear(const Euler<T> &target) noexcept¶
Adjusts “this” Euler so that its components differ from target by as little as possible.
This method might not make sense for Eulers with different order and it probably doesn’t work for repeated axis and relative orderings (TODO).
Public Types
-
enum Order¶
All 24 possible orderings.
Values:
-
enumerator XYZ¶
-
enumerator XZY¶
-
enumerator YZX¶
-
enumerator YXZ¶
-
enumerator ZXY¶
-
enumerator ZYX¶
-
enumerator XZX¶
-
enumerator XYX¶
-
enumerator YXY¶
-
enumerator YZY¶
-
enumerator ZYZ¶
-
enumerator ZXZ¶
-
enumerator XYZr¶
-
enumerator XZYr¶
-
enumerator YZXr¶
-
enumerator YXZr¶
-
enumerator ZXYr¶
-
enumerator ZYXr¶
-
enumerator XZXr¶
-
enumerator XYXr¶
-
enumerator YXYr¶
-
enumerator YZYr¶
-
enumerator ZYZr¶
-
enumerator ZXZr¶
-
enumerator Legal¶
-
enumerator Min¶
-
enumerator Max¶
-
enumerator Default¶
-
enumerator XYZ¶
-
constexpr Euler() noexcept¶
