Enum EulerRot

pub enum EulerRot {
    ZYX,
    ZXY,
    YXZ,
    YZX,
    XYZ,
    XZY,
    ZYZ,
    ZXZ,
    YXY,
    YZY,
    XYX,
    XZX,
    ZYXEx,
    ZXYEx,
    YXZEx,
    YZXEx,
    XYZEx,
    XZYEx,
    ZYZEx,
    ZXZEx,
    YXYEx,
    YZYEx,
    XYXEx,
    XZXEx,
}

Rotation Helper Euler rotation sequences.

The three elemental rotations may be extrinsic (rotations about the axes xyz of the original coordinate system, which is assumed to remain motionless), or intrinsic(rotations about the axes of the rotating coordinate system XYZ, solidary with the moving body, which changes its orientation after each elemental rotation).

let m_intrinsic = Mat3::from_rotation_x(i) * Mat3::from_rotation_y(j) * Mat3::from_rotation_z(k);
let n_intrinsic = Mat3::from_euler(EulerRot::XYZ, i, j, k);
assert!(m_intrinsic.abs_diff_eq(n_intrinsic, 2e-6));

let m_extrinsic = Mat3::from_rotation_z(k) * Mat3::from_rotation_y(j) * Mat3::from_rotation_x(i);
let n_extrinsic = Mat3::from_euler(EulerRot::XYZEx, i, j, k);
assert!(m_extrinsic.abs_diff_eq(n_extrinsic, 2e-6));

Variants

ZYX

Intrinsic three-axis rotation ZYX

ZXY

Intrinsic three-axis rotation ZXY

YXZ

Intrinsic three-axis rotation YXZ

YZX

Intrinsic three-axis rotation YZX

XYZ

Intrinsic three-axis rotation XYZ

XZY

Intrinsic three-axis rotation XZY

ZYZ

Intrinsic two-axis rotation ZYZ

ZXZ

Intrinsic two-axis rotation ZXZ

YXY

Intrinsic two-axis rotation YXY

YZY

Intrinsic two-axis rotation YZY

XYX

Intrinsic two-axis rotation XYX

XZX

Intrinsic two-axis rotation XZX

ZYXEx

Extrinsic three-axis rotation ZYX

ZXYEx

Extrinsic three-axis rotation ZXY

YXZEx

Extrinsic three-axis rotation YXZ

YZXEx

Extrinsic three-axis rotation YZX

XYZEx

Extrinsic three-axis rotation XYZ

XZYEx

Extrinsic three-axis rotation XZY

ZYZEx

Extrinsic two-axis rotation ZYZ

ZXZEx

Extrinsic two-axis rotation ZXZ

YXYEx

Extrinsic two-axis rotation YXY

YZYEx

Extrinsic two-axis rotation YZY

XYXEx

Extrinsic two-axis rotation XYX

XZXEx

Extrinsic two-axis rotation XZX

Trait Implementations

impl Clone for EulerRot

fn clone(&self) -> EulerRot

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EulerRot

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for EulerRot

fn default() -> Self

Default YXZ as yaw (y-axis), pitch (x-axis), roll (z-axis).

impl<'de> Deserialize<'de> for EulerRot

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for EulerRot

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EulerRot

fn eq(&self, other: &EulerRot) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for EulerRot

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Copy for EulerRot

impl Eq for EulerRot

impl StructuralPartialEq for EulerRot