euler.h File Reference

Go to the source code of this file.

Data Structures
struct	EulerAngles
	Storage for Euler angles with an associated rotation order. More...

Enumerations
enum	EulerOrder { EULER_ZYX , EULER_ZYZ , EULER_XYZ }
	Enumeration of supported Euler rotation orders. More...

Functions
void	euler_to_dcm (const EulerAngles *e, double dcm[3][3])
	Convert Euler angles to a direction cosine matrix.
int	euler_to_dcm_checked (const EulerAngles *e, double dcm[3][3])
	Checked Euler-to-DCM conversion.
void	euler_to_quaternion (const EulerAngles *e, double q[4])
	Convert Euler angles to a quaternion.
int	euler_to_quaternion_checked (const EulerAngles *e, double q[4])
	Checked Euler-to-quaternion conversion.

Enumeration Type Documentation

EulerOrder

enum EulerOrder

Enumeration of supported Euler rotation orders.

The library currently implements intrinsic ZYX rotations. The other values are reserved so callers can reject unsupported inputs through the checked API.

Enumerator
EULER_ZYX	Standard aerospace yaw → pitch → roll sequence.
EULER_ZYZ	Useful for certain satellite pointing laws and robotics arms.
EULER_XYZ	Roll → pitch → yaw intrinsic sequence.

Definition at line 14 of file euler.h.

             {
    EULER_ZYX, 
    EULER_ZYZ, 
    EULER_XYZ, 
    // Extend with other orders as needed.
} EulerOrder;

Function Documentation

euler_to_dcm()

void euler_to_dcm	(	const EulerAngles *	e,
		double	dcm[3][3]
	)

Convert Euler angles to a direction cosine matrix.

Parameters

e	Euler angle container in radians.
dcm	Output \(3\times3\) matrix (row-major).

Definition at line 41 of file euler.c.

                                                          {
    if (!euler_to_dcm_checked(e, dcm)) {
        set_nan_matrix(dcm);
    }
}

euler_to_dcm_checked()

int euler_to_dcm_checked	(	const EulerAngles *	e,
		double	dcm[3][3]
	)

Checked Euler-to-DCM conversion.

Returns

1 on success, 0 for null pointers, non-finite angles, or an unsupported order.

Definition at line 16 of file euler.c.

                                                                 {
    if (e == NULL || dcm == NULL || e->order != EULER_ZYX ||
        !isfinite(e->roll) || !isfinite(e->pitch) || !isfinite(e->yaw)) {
        return 0;
    }
 
    double cr = cos(e->roll);
    double sr = sin(e->roll);
    double cp = cos(e->pitch);
    double sp = sin(e->pitch);
    double cy = cos(e->yaw);
    double sy = sin(e->yaw);
 
    dcm[0][0] = cy*cp;
    dcm[0][1] = cy*sp*sr - sy*cr;
    dcm[0][2] = cy*sp*cr + sy*sr;
    dcm[1][0] = sy*cp;
    dcm[1][1] = sy*sp*sr + cy*cr;
    dcm[1][2] = sy*sp*cr - cy*sr;
    dcm[2][0] = -sp;
    dcm[2][1] = cp*sr;
    dcm[2][2] = cp*cr;
    return 1;
}

euler_to_quaternion()

void euler_to_quaternion	(	const EulerAngles *	e,
		double	q[4]
	)

Convert Euler angles to a quaternion.

Parameters

e	Euler angle container in radians.
q	Output quaternion in \([w, x, y, z]\) order.

Definition at line 67 of file euler.c.

                                                            {
    if (!euler_to_quaternion_checked(e, q) && q != NULL) {
        for (int index = 0; index < 4; ++index) {
            q[index] = NAN;
        }
    }
}

euler_to_quaternion_checked()

int euler_to_quaternion_checked	(	const EulerAngles *	e,
		double	q[4]
	)

Checked Euler-to-quaternion conversion.

Returns

1 on success, 0 for null pointers, non-finite angles, or an unsupported order.

Definition at line 47 of file euler.c.

                                                                   {
    if (e == NULL || q == NULL || e->order != EULER_ZYX ||
        !isfinite(e->roll) || !isfinite(e->pitch) || !isfinite(e->yaw)) {
        return 0;
    }
 
    double cr = cos(e->roll/2.0);
    double sr = sin(e->roll/2.0);
    double cp = cos(e->pitch/2.0);
    double sp = sin(e->pitch/2.0);
    double cy = cos(e->yaw/2.0);
    double sy = sin(e->yaw/2.0);
 
    q[0] = cr*cp*cy + sr*sp*sy; // w
    q[1] = sr*cp*cy - cr*sp*sy; // x
    q[2] = cr*sp*cy + sr*cp*sy; // y
    q[3] = cr*cp*sy - sr*sp*cy; // z
    return 1;
}