Quaternion.hpp

Go to the documentation of this file.

//
// This file is part of MorphoGraphX - http://www.MorphoGraphX.org
// Copyright (C) 2012-2015 Richard S. Smith and collaborators.
//
// If you use MorphoGraphX in your work, please cite:
//   http://dx.doi.org/10.7554/eLife.05864
//
// MorphoGraphX is free software, and is licensed under under the terms of the 
// GNU General (GPL) Public License version 2.0, http://www.gnu.org/licenses.
// 
#ifndef QUATERNION_HPP
#define QUATERNION_HPP
 
 
#include <Config.hpp>
 
#include <Geometry.hpp>
#include <Matrix.hpp>
#include <Vector.hpp>
 
namespace mgx 
{
  struct Quaternion : public Point4d {
    Quaternion() : Point4d(0, 0, 0, 1) {}
  
    Quaternion(const Point4d &other) : Point4d(other) {}
  
    Quaternion(double x, double y, double z, double w) : Point4d(x, y, z, w) {}
  
    Quaternion(const Quaternion &other) : Point4d(other) {}
  
    Quaternion(const Point3d &axis, double angle);
  
    Quaternion(const Point3d &from, const Point3d &to);
  
    Quaternion(const Matrix3d &m);
  
    Quaternion &operator=(const Quaternion &other);
  
    void setAxisAngle(const Point3d &axis, double angle);
  
    double &w() { return elems[3]; }
    const double &w() const { return elems[3]; }
  
    Quaternion &operator+=(const Quaternion &other)
    {
      for(size_t i = 0; i < 4; ++i)
        elems[i] += other.elems[i];
      return *this;
    }
  
    Quaternion operator+(const Quaternion &other) const
    {
      Quaternion tmp(*this);
      tmp += other;
      return tmp;
    }
  
    Quaternion operator*(const Quaternion &other) const;
    Quaternion &operator*=(const Quaternion &other);
  
    Quaternion &operator*=(double s)
    {
      for(size_t i = 0; i < 4; ++i)
        elems[i] *= s;
      return *this;
    }
  
    Quaternion inverse() const
    {
      double n = mgx::normsq(*this);
      return Quaternion(-x() / n, -y() / n, -z() / n, w() / n);
    }
  
    Quaternion conjugate() const {
      return Quaternion(-x(), -y(), -z(), w());
    }
  
    Quaternion &operator/=(double v)
    {
      for(size_t i = 0; i < 4; ++i)
        elems[i] /= v;
      return *this;
    }
  
    Quaternion operator/(double v) const
    {
      Quaternion tmp(*this);
      tmp /= v;
      return tmp;
    }
  
    void setMatrix(Matrix3d &m) const;
    void setMatrix(Matrix4d &m) const;
  
    Point3d axis() const;
  
    double angle() const;
  
    Point3d rotate(const Point3d &v) const;
  
    Point3d inverseRotate(const Point3d &v) const;
  };
  
  Quaternion slerp(const Quaternion &q1, const Quaternion &q2, double t);
  
  inline Quaternion operator*(double s, const Quaternion& q)
  {
    Quaternion tmp(q);
    tmp *= s;
    return tmp;
  }
  
  inline Quaternion operator*(const Quaternion &q, double s)
  {
    Quaternion tmp(q);
    tmp *= s;
    return tmp;
  }
}
 
namespace std 
{
  mgx::Quaternion pow(const mgx::Quaternion &q, double p);
}
 
#endif