Euler.h

Go to the documentation of this file.

 
#include "ReferenceFrame.h"
 
#ifndef _GAMS_POSE_EULER_H_
#define _GAMS_POSE_EULER_H_
 
#include <iostream>
#include <cmath>
#include "Orientation.h"
#include "AngleUnits.h"
#include "Quaternion.h"
 
namespace gams
{
  namespace pose
  {
    namespace euler
    {
      namespace conv
      {
        struct Intr
        {
          static const char *name() { return "Intr"; }
 
          static const bool reverse = false;
        };
 
        struct Extr
        {
          static const char *name() { return "Extr"; }
 
          /* Conversion formulas are in terms of intrinsic convention; to use
           * them for extrinsic convention, we just need to pass the arguments
           * in reverse order. This flag communicates this need. */
          static const bool reverse = true;
        };
 
        struct X
        {
          static const char *name() { return "X"; }
        };
 
        struct Y
        {
          static const char *name() { return "Y"; }
        };
 
        struct Z
        {
          static const char *name() { return "Z"; }
        };
      } // namespace conv
    }
  }
}
 
#include "gams/pose/EulerFormulas.inl"
 
namespace gams
{
  namespace pose
  {
    namespace euler
    {
      template<typename A, typename B, typename C, typename Conv = conv::Intr>
      class Euler
      {
      private:
        typedef typename detail::GetTypes<A,B,C,Conv>::F F;
        typedef typename detail::GetTypes<A,B,C,Conv>::Trig Trig;
      public:
        Euler() : a_(0), b_(0), c_(0) {}
 
        Euler(double a, double b, double c) : a_(a), b_(b), c_(c) {}
 
        template<typename Unit>
        Euler(double a, double b, double c, Unit u);
 
        explicit Euler(const Quaternion &quat);
 
        template<typename A2, typename B2, typename C2, typename Conv2>
        explicit Euler(const Euler<A2, B2, C2, Conv2> &o);
 
        explicit Euler(const OrientationVector &r);
 
        double a() const { return a_; }
        double b() const { return b_; }
        double c() const { return c_; }
 
        void a(double n) { a_ = n; }
        void b(double n) { b_ = n; }
        void c(double n) { c_ = n; }
 
        Quaternion to_quat() const;
 
        Orientation to_orientation() const;
 
        Orientation to_orientation(const ReferenceFrame &frame) const;
 
        static Euler from_quat(const Quaternion &quat);
      private:
        double a_, b_, c_;
 
        void set_from_quat(const Quaternion &quat);
      };
 
      typedef Euler<conv::X, conv::Y, conv::Z>             EulerXYZ;
      typedef Euler<conv::Y, conv::X, conv::Z>             EulerYXZ;
      typedef Euler<conv::X, conv::Y, conv::Z, conv::Intr> EulerIntrXYZ;
      typedef Euler<conv::Y, conv::X, conv::Z, conv::Intr> EulerIntrYXZ;
      typedef Euler<conv::X, conv::Y, conv::Z, conv::Extr> EulerExtrXYZ;
      typedef Euler<conv::Y, conv::X, conv::Z, conv::Extr> EulerExtrYXZ;
      typedef Euler<conv::Z, conv::Y, conv::X>             EulerZYX;
      typedef Euler<conv::Z, conv::Y, conv::X, conv::Intr> EulerIntrZYX;
      typedef Euler<conv::Z, conv::Y, conv::X, conv::Extr> EulerExtrZYX;
 
      typedef EulerIntrXYZ EulerVREP;
 
      typedef EulerIntrZYX EulerYPR;
 
      typedef EulerYPR YawPitchRoll;
 
      typedef EulerExtrXYZ RollPitchYaw;
 
      template<typename A, typename B, typename C, typename Conv>
      std::ostream &operator<<(std::ostream &o, const Euler<A, B, C, Conv> &e);
    }
  }
}
 
#include "Euler.inl"
 
#endif