Rotation.h

Go to the documentation of this file.

/*  \todo Implement Gibbs vector representation
 */

#ifndef __OSESSAME_ROTATION_H__
#define __OSESSAME_ROTATION_H__
#include <math.h>
#include "Matrix.h"
#include "MathUtils.h"
using namespace O_SESSAME;

namespace O_SESSAME {
// Prototype definitions of classes in Rotation Toolbox
class Quaternion;
class DirectionCosineMatrix;
class ModifiedRodriguezParameters;
class Rotation;                 


const int QUATERNION_SIZE = 4;
const int MRP_SIZE = 3;
const int DCM_SIZE = 3;
const int EULERAXIS_SIZE = 3;
const int EULERANGLES_SIZE = 3;

enum RotationType{DCM_Type, EulerAngle_Type, EulerAxisAngle_Type, MRP_Type, Quaternion_Type};

enum RotationSense{LEFT_HAND = -1, RIGHT_HAND = 1};



class DirectionCosineMatrix:public Matrix
{
public:

    // DCM CONSTROCTURS
    DirectionCosineMatrix();
    
    DirectionCosineMatrix(const DirectionCosineMatrix& _DCM);

    DirectionCosineMatrix(const Matrix& _DCM);

    DirectionCosineMatrix(const Vector& _EulerAngles, const int& _Sequence);

    DirectionCosineMatrix(const Vector& _EulerAxis, const Angle& _EulerAngle);

    DirectionCosineMatrix(const Angle& _Angle1, const Angle& _Angle2, const Angle& _Angle3, const int& _Sequence);

    DirectionCosineMatrix(const ModifiedRodriguezParameters& _MRP);

    DirectionCosineMatrix(const Quaternion& _quat);
    
    virtual ~DirectionCosineMatrix();

    // DCM MUTATORS
    void Set(const DirectionCosineMatrix& _DCM);

    void Set(const Matrix& _DCM);
    
    void Set(const Vector& _EulerAngles, const int& _Sequence);

    void Set(const Angle& _Angle1, const Angle& _Angle2, const Angle& _Angle3, const int& _Sequence);

    void Set(const Vector& _EulerAxis, const Angle& _EulerAngle);

    void Set(const ModifiedRodriguezParameters& _MRP);
    
    void Set(const Quaternion& _qIn);

    // DCM INSPECTORS
    Vector GetEulerAngles(const int& _Sequence) const;

    void GetEulerAxisAngle(Vector& _EulerAxis, Angle& _EulerAngle) const;
    
    ModifiedRodriguezParameters GetMRP() const;
    
    Quaternion GetQuaternion() const;

    // DCM OPERATORS
    void Normalize();

    DirectionCosineMatrix operator+ (const DirectionCosineMatrix& _DCM2) const;
    
    DirectionCosineMatrix operator- (const DirectionCosineMatrix& _DCM2) const;

    inline DirectionCosineMatrix operator* (DirectionCosineMatrix _DCM2) const;

    inline Vector operator* (const Vector& _vec) const;

    inline DirectionCosineMatrix operator~ ();
    
};


DirectionCosineMatrix R1(const Angle& _Angle);

DirectionCosineMatrix R2(const Angle& _Angle);

DirectionCosineMatrix R3(const Angle& _Angle);
// end of DirectionCosineMatrix


class ModifiedRodriguezParameters:public Vector
{
public:
    // MRP CONSTRUCTORS
    ModifiedRodriguezParameters();

    ModifiedRodriguezParameters(const ModifiedRodriguezParameters& _MRP);
    
    ModifiedRodriguezParameters(const double& _s1, const double& _s2, const double& _s3);

    ModifiedRodriguezParameters(const Vector& _sVector);

    ModifiedRodriguezParameters(const DirectionCosineMatrix& _DCM);

    ModifiedRodriguezParameters(const Vector& _Angles, const int& _Sequence);

    ModifiedRodriguezParameters(const Vector& _EulerAxis, const Angle& _EulerAngle);

    ModifiedRodriguezParameters(const Quaternion& _qIN);

    // MRP MUTATORS
    void Set(const ModifiedRodriguezParameters& _MRP);

    void Set(const double& _s1, const double& _s2, const double& _s3);

    void Set(const Vector& _sVector);

    void Set(const DirectionCosineMatrix& _DCM);

    void Set(const Vector& _EulerAngles, const int& _Sequence);

    void Set(const Angle& _Angle1, const Angle& _Angle2, const Angle& _Angle3, const int& _Sequence);

    void Set(const Vector& _EulerAxis, const Angle& _EulerAngle);

    void Set(const Quaternion& _qIN);

    // MRP INSPECTORS
    DirectionCosineMatrix GetDCM() const;

    Vector GetEulerAngles(int _Sequence) const;

    void GetEulerAxisAngle(Vector& _EulerAxis, Angle& _EulerAngle) const;

    Quaternion GetQuaternion() const;

    // MRP OPERATORS
    void Switch(int _SwitchThreshold = 1);

    void AutoSwitch(bool _SwitchBoolean = false);

    ModifiedRodriguezParameters ShadowSet() const;

    ModifiedRodriguezParameters operator+ (const ModifiedRodriguezParameters& _MRP2) const;

    ModifiedRodriguezParameters operator- (const ModifiedRodriguezParameters& _MRP2) const;
    // end of MRPOperators
private:
    bool m_AutoSwitch;
};
// end of ModifiedRodriguezParameters


class Quaternion:public Vector
{
public:
    // QUATERNION CONSTRUCTORS
    Quaternion();

    Quaternion(double _q1, double _q2, double _q3, double _q4);

//    Quaternion(const Matrix& _qMatrix);

    Quaternion(const Vector& _qVector);

    Quaternion(const DirectionCosineMatrix& _DCM);

    Quaternion(const Vector& _EulerAngles, const int& _Sequence);

    Quaternion(const Vector& _EulerAxis, const Angle& _EulerAngle);

    Quaternion(const ModifiedRodriguezParameters& _MRP);

    // QUATERNION MUTATORS
    void Set(const Quaternion& _qIn);

    void Set(double _q1, double _q2, double _q3, double _q4);

//    void Set(const Matrix& _qMatrix);

    void Set(const Vector& _qVector);

    void Set(const DirectionCosineMatrix& _DCM);

    void Set(const Vector& _EulerAngles, const int& _Sequence);

    void Set(const Vector& _EulerAxis, const Angle& _EulerAngle);

    void Set(const ModifiedRodriguezParameters& _MRP);

    // QUATERNION INSPECTORS
    DirectionCosineMatrix GetDCM() const;

    Vector GetEulerAngles(const int& _Sequence) const;

    Vector GetEulerAxisAngle(Vector& _EulerAxis, Angle& _EulerAngle) const;

    Vector GetEulerAxisAngle() const;

    ModifiedRodriguezParameters GetMRP() const;

    // QUATERNION OPERATORS
    void Normalize();
    
    Quaternion operator+ (const Quaternion& _quat2) const;

    Quaternion operator- (const Quaternion& _quat2) const;

private:

};
// end of Quaternion


class Rotation
{
public:
    // ROTATION CONSTRUCTORS
    Rotation();

    Rotation(const Matrix& _inMatrix);

    Rotation(const DirectionCosineMatrix& _DCM);

    Rotation(const Vector& _Angles, const int& _Sequence);

    Rotation(const Angle& _Angle1, const Angle& _Angle2, const Angle& _Angle3, const int& _Sequence);

    Rotation(const Vector& _Axis, const Angle& _Angle);

    Rotation(const ModifiedRodriguezParameters& _MRP);

    Rotation(const Quaternion& _quat);

     virtual ~Rotation();

    // ROTATION MUTATORS
    void Set(const Matrix& _inMatrix);

    void Set(const DirectionCosineMatrix& _DCM);

    void Set(const Vector& _Angles, const int& _Sequence);

    void Set(const Angle& _Angle1, const Angle& _Angle2, const Angle& _Angle3, const int& _Sequence);

    void Set(const Vector& _Axis, const Angle& _Angle);

    void Set(const ModifiedRodriguezParameters& _MRP);

    void Set(const Quaternion& _quat);

    // end of RotationMutators

    // ROTATION INSPECTORS
    DirectionCosineMatrix GetDCM() const;

    Vector GetEulerAngles(const int& _Sequence) const;

    Vector GetEulerAxisAngle(Vector& _EulerAxis, Angle& _EulerAngle) const;

    Vector GetEulerAxisAngle() const;
    
    ModifiedRodriguezParameters GetMRP() const;

    Quaternion GetQuaternion() const;

    Vector GetRotation(const RotationType& _type, const int& _Sequence = 123) const;
    
    // ROTATION OPERATORS
    Rotation Rotation::operator* (const Rotation& _rot2) const;

    Vector Rotation::operator* (const Vector& _vec) const;
    
    Rotation Rotation::operator~ () const;

    Rotation Rotation::operator+ (const Rotation& _rot2) const;

    Rotation Rotation::operator- (const Rotation& _rot2) const;
    // end of RotationOperators

private:
        Quaternion m_quaternion;
        
        RotationSense m_RotationSense;

};
}

#endif 
/*!***************************************************************************
*       $Log: Rotation.h,v $
*       Revision 1.17  2003/05/22 03:03:38  nilspace
*       Update documentation, and changed all angles to use Angle type.
*       
*       Revision 1.16  2003/05/21 22:18:05  nilspace
*       Moved the documentation to the implementation file.
*       
*       Revision 1.15  2003/05/20 17:53:51  nilspace
*       Updated comments.
*       
*       Revision 1.14  2003/05/13 19:45:10  nilspace
*       Updated comments.
*       
*       Revision 1.13  2003/04/28 14:16:26  nilspace
*       Moved all function definitions out of header file into implementation file.
*       
*       Revision 1.12  2003/04/27 20:41:10  nilspace
*       Encapsulated the rotation library into the namespace O_SESSAME.
*       
*       Revision 1.11  2003/04/23 14:56:18  simpliciter
*       Clarified comments on quaternions (automatic normalization) and
*       outputting rotations (can't do it).
*       
*       Revision 1.10  2003/04/22 21:59:58  nilspace
*       Fixed Quaternion::Set(DCM) so it evaluates correctly.
*       Implemented Rotation::operator-()
*       
*       Revision 1.9  2003/04/22 19:36:03  nilspace
*       Various bug fixes to DCM & quaternion conversions. Added DirectionCosineMatrix Normalize().
*       
*       Revision 1.8  2003/04/22 16:03:11  nilspace
*       Updated MRP::Set(Quaternion) to correctly set.
*       
*       Revision 1.7  2003/04/10 17:25:52  nilspace
*       changelog
*       
*       Revision 1.6  2003/04/08 23:02:27  nilspace
*       Added Rotation Sense, or "Handedness". Defaults to RIGHT_HAND
*       
*       Revision 1.5  2003/03/27 20:22:27  nilspace
*       Added GetRotation() function.
*       Fixed Quaternion.Set(Quaternion) function.
*       Added RotationType enum.
*       Made sure to normalize the Quaternions for all the Set() functions.
*       
*       Revision 1.4  2003/03/25 02:37:36  nilspace
*       Added quaternion matrix set and constructor.
*       Added Rotation generalized matrix set to check for quaternion.
*       
*       Revision 1.3  2003/03/04 17:36:20  nilspace
*       Added CVS tags for documenting uploads. Also chmod'd to not be executable.
*       
*       Revision 1.1  2003/02/27 18:37:26  nilspace
*       Initial submission of Attitude class implementation.
*       
*
******************************************************************************/

---