rotlib.h

Go to the documentation of this file.

#ifndef  ROTLIB_H
#define ROTLIB_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdbool.h>


enum EulangSeq {ES_XYZ, ES_XZY, ES_YXZ, ES_YZX, ES_ZXY, ES_ZYX};
 
/******************************************************************************/
                            /* UTILITY FUNCTIONS */
/******************************************************************************/


void align(const int n, const double* v, const int m, const double* old, 
        const double* new, double* valigned);

bool mat_is_rotmat(const double* mat);

 
/******************************************************************************/
                               /* QUATERNIONS */
/******************************************************************************/


void quat_rand(double q[4]);

void quat_identity(double q[4]);

void quat_conjugated(double q[4]);

void quat_inverted(double q[4]);

void quat_normalized(double q[4]);

bool quat_is_normalized(const double q[4]);

void quat_prod(const double p[4], const double q[4], double pq[4],
        bool normalize);

double quat_angle_between(const double p[4], const double q[4]);

void quat_interpolate(const double q1[4], const double q2[4], const double t,
        double q[4]);

void quat_deriv_to_angvel_mat(const double q[4], double* mat);

void quat_deriv_to_angvel(const double q[4], const double qdot[4], 
        double angvel[3]);

void quat_deriv_from_angvel_mat(const double q[4], double* mat);

void quat_deriv_from_angvel(const double q[4], const double angvel[3],
        double qdot[4]);

void quat_rotmat(const double q[4], double* rotmat);

void quat_shiftmat(const double q[4], const bool forward,
        double* shiftmat);

void quat_rotate_vectors(const int n, const double* v, const double q[4],
        double* vrot);

void quat_shift_vectors(const int n, const double* v, const double q[4],
        const bool forward, double* vshift);

void quat_shift_tensor2(const double* A, const double q[4],
        const bool forward, double* Ashift);

void quat_shift_tensor3(const double* A, const double q[4],
        const bool forward, double* Ashift);

void quat_to_aa(const double q[4], double axis[3], double* angle);

void quat_to_dcm(const double q[4], double* dcm);

void quat_to_euler(const double q[4], enum EulangSeq seq, const bool world,
        double euler[3]);
 
/******************************************************************************/
                                /* AXIS ANGLE */
/******************************************************************************/


void aa_fix(double axis[3], double* angle, const bool normalize);

void aa_rand(double axis[3], double* angle);

void aa_rotmat(const double axis[3], const double angle,
        double* rotmat);

void aa_from_rotmat(const double* rotmat, double axis[3], double* angle);

void aa_rotate_vectors(const int n, const double* v, const double axis[3],
        const double angle, double* vrot);

void aa_shiftmat(const double axis[3], const double angle,
        const bool forward, double* shiftmat);

void aa_shift_vectors(const int n, const double* v, 
        const double axis[3], const double angle, const bool forward,
        double* vshift);

void aa_shift_tensor2(const double* A, const double axis[3],
        const double angle, const bool forward, double* Ashift);

void aa_shift_tensor3(const double* A, const double axis[3],
        const double angle, const bool forward, double* Ashift);

void aa_to_quat(const double axis[3], const double angle, double q[4]);

void aa_to_dcm(const double axis[3], const double angle, double* dcm);

void aa_to_euler(const double axis[3], const double angle, 
        enum EulangSeq seq, const bool world, double euler[3]);
 
/******************************************************************************/
                         /* DIRECTION COSINE MATRIX */
/******************************************************************************/

 
bool mat_is_dcm(const double* mat);

void dcm_from_axes(const double* A, const double* B, double* dcm);

void dcm_rotmat(const double* dcm, double* rotmat);

void dcm_shiftmat(const double* dcm, const bool forward, double* shiftmat);

void dcm_rotate_vectors(const int n, const double* v, const double* dcm,
        double* vrot);

void dcm_shift_vectors(const int n, const double* v, const double* dcm,
        const bool forward, double* vshift);

void dcm_shift_tensor2(const double* A, const double* dcm, const bool forward,
        double* Ashift);

void dcm_shift_tensor3(const double* A, const double* dcm, const bool forward,
        double* Ashift);

void dcm_to_quat(const double* dcm, double q[4]);

void dcm_to_aa(const double* dcm, double axis[3], double* angle);

void dcm_to_euler(const double* dcm, enum EulangSeq seq, const bool world,
        double euler[3]);
 
/******************************************************************************/
                               /* EULER ANGLES */
/******************************************************************************/


void euler_rotmat(const double euler[3], enum EulangSeq seq, const bool world,
        double* rotmat);

void euler_shiftmat(const double euler[3], enum EulangSeq seq, const bool world,
        const bool forward, double* shiftmat);

void euler_rotate_vectors(const int n, const double* v, const double euler[3],
        enum EulangSeq seq, const bool world, double* vrot);

void euler_shift_vectors(const int n, const double* v, const double euler[3],
        enum EulangSeq seq, const bool world, const bool forward,
        double* vshift);

void euler_shift_tensor2(const double* A, const double euler[3],
        enum EulangSeq seq, const bool world, const bool forward, double* Ashift);

void euler_shift_tensor3(const double* A, const double euler[3],
        enum EulangSeq seq, const bool world, const bool forward, double* Ashift);

void euler_to_quat(const double euler[3], enum EulangSeq seq, const bool world,
        double q[4]);

void euler_to_aa(const double euler[3], enum EulangSeq seq, const bool world,
        double axis[3], double* angle);

void euler_to_dcm(const double euler[3], enum EulangSeq seq, const bool world,
        double* dcm);

void euler_to_euler(const double euler[3], enum EulangSeq seq, const bool world,
        enum EulangSeq to_seq, const bool to_world, double to_euler[3]);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ROTLIB_H */