Quaternion.h

Go to the documentation of this file.

 
#include "ReferenceFrame.h"
 
#ifndef _GAMS_POSE_QUATERNION_H_
#define _GAMS_POSE_QUATERNION_H_
 
#include <iostream>
#include <cmath>
#include "gams/CPP11_compat.h"
 
namespace gams
{
  namespace pose
  {
    class OrientationVector;
    class PositionVector;
 
    class Quaternion
    {
    public:
      constexpr Quaternion() : x_(0), y_(0), z_(0), w_(0) {}
 
      constexpr Quaternion(double x, double y, double z, double w);
 
      Quaternion(double rx, double ry, double rz);
 
      explicit Quaternion(const OrientationVector &rot);
 
      explicit Quaternion(const PositionVector &loc);
 
      void from_linear_vector(double x, double y, double z);
 
      void from_linear_vector(const PositionVector &loc);
 
      void to_linear_vector(double &x, double &y, double &z) const;
 
      void to_linear_vector(PositionVector &loc) const;
 
      void from_angular_vector(double rx, double ry, double rz);
 
      void from_angular_vector(const OrientationVector &rot);
 
      void to_angular_vector(double &rx, double &ry, double &rz) const;
 
      void to_angular_vector(OrientationVector &rot) const;
 
      static void hamilton_product(
              Quaternion &into, const Quaternion &lhs, const Quaternion &rhs);
 
      Quaternion &operator*=(const Quaternion &rhs);
 
      Quaternion operator*(const Quaternion &rhs) const;
 
      void pre_multiply(const Quaternion &lhs)
      {
        hamilton_product(*this, lhs, *this);
      }
 
      Quaternion &conjugate();
 
      Quaternion &negate();
 
      void orient_by(Quaternion rot);
 
      constexpr Quaternion operator-() const;
 
      double inner_product(const Quaternion &rhs) const;
 
      double dot_product(const Quaternion &rhs) const;
 
      double angle_to(const Quaternion &target) const;
 
      constexpr double x() const;
 
      constexpr double y() const;
 
      constexpr double z() const;
 
      constexpr double w() const;
 
      double x(double new_x);
 
      double y(double new_y);
 
      double z(double new_z);
 
      double w(double new_w);
 
      void invert();
 
      double mag() const;
 
      double imag() const;
 
      double mag_squared() const;
 
      void scale(double s);
 
      Quaternion exp() const;
 
      void exp_this();
 
      Quaternion ln() const;
 
      void ln_this();
 
      Quaternion pow(double e) const;
 
      void pow_this(double e);
 
      Quaternion pow(const Quaternion &e) const;
 
      void pow_this(const Quaternion &e);
 
      Quaternion slerp(const Quaternion &o, double t);
 
      void slerp_this(const Quaternion &o, double t);
 
      /* The methods below return the cells of the 3x3 orientation matrix this
       * quaternion represents; names are mRC(), where R is row, and C is column
       */
 
      double m11() const;
 
      double m12() const;
 
      double m13() const;
 
      double m21() const;
 
      double m22() const;
 
      double m23() const;
 
      double m31() const;
 
      double m32() const;
 
      double m33() const;
 
    private:
      double x_, y_, z_, w_;
    };
 
 
    inline default_rotational_unit_traits::storage_mixin::storage_mixin(
        const Quaternion &quat)
    {
      quat.to_angular_vector(vec()[0], vec()[1], vec()[2]);
    }
  }
}
 
#include "Quaternion.inl"
 
#endif