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