WFMath 0.3.12
quaternion.h
00001 // quaternion.h (based on the Quaternion class from eris)
00002 //
00003 //  The WorldForge Project
00004 //  Copyright (C) 2002  The WorldForge Project
00005 //
00006 //  This program is free software; you can redistribute it and/or modify
00007 //  it under the terms of the GNU General Public License as published by
00008 //  the Free Software Foundation; either version 2 of the License, or
00009 //  (at your option) any later version.
00010 //
00011 //  This program is distributed in the hope that it will be useful,
00012 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 //  GNU General Public License for more details.
00015 //
00016 //  You should have received a copy of the GNU General Public License
00017 //  along with this program; if not, write to the Free Software
00018 //  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00019 //
00020 //  For information about WorldForge and its authors, please contact
00021 //  the Worldforge Web Site at http://www.worldforge.org.
00022 //
00023 
00024 // Author: Ron Steinke
00025 
00026 #ifndef WFMATH_QUATERNION_H
00027 #define WFMATH_QUATERNION_H
00028 
00029 #include <wfmath/vector.h>
00030 #include <wfmath/rotmatrix.h>
00031 
00032 namespace WFMath {
00033 
00035 
00039 class Quaternion
00040 {
00041  public:
00043   Quaternion () : m_w(0), m_vec(), m_valid(false), m_age(0) {}
00045 
00048   Quaternion (CoordType w_in, CoordType x_in, CoordType y_in, CoordType z_in);
00050   Quaternion (int axis, CoordType angle) : m_w(0), m_vec(), m_valid(false),
00051                                            m_age(0)
00052     {rotation(axis, angle);}
00054   Quaternion (const Vector<3>& axis, CoordType angle) : m_w(0), m_vec(),
00055                                                         m_valid(false),
00056                                                         m_age(0)
00057     {rotation(axis, angle);}
00059 
00062   explicit Quaternion (const Vector<3>& axis) : m_w(0), m_vec(),
00063                                                 m_valid(false), m_age(0)
00064     {rotation(axis);} // angle == axis.mag()
00066   Quaternion (const Quaternion& p) : m_w(p.m_w), m_vec(p.m_vec),
00067                                      m_valid(p.m_valid), m_age(p.m_age) {}
00069   explicit Quaternion (const AtlasInType& a) : m_w(0), m_vec(),
00070                                                m_valid(false), m_age(0)
00071     {fromAtlas(a);}
00072 
00073   ~Quaternion() {}
00074 
00075   friend std::ostream& operator<<(std::ostream& os, const Quaternion& p);
00076   friend std::istream& operator>>(std::istream& is, Quaternion& p);
00077 
00079   AtlasOutType toAtlas() const;
00081   void fromAtlas(const AtlasInType& a);
00082 
00083   Quaternion& operator= (const Quaternion& rhs)
00084         {m_w = rhs.m_w; m_vec = rhs.m_vec; m_valid = rhs.m_valid; m_age = rhs.m_age; return *this;}
00085 
00086   // This regards q and -1*q as equal, since they give the
00087   // same RotMatrix<3>
00088   bool isEqualTo(const Quaternion &q, double epsilon = WFMATH_EPSILON) const;
00089 
00090   bool operator== (const Quaternion& rhs) const {return isEqualTo(rhs);}
00091   bool operator!= (const Quaternion& rhs) const {return !isEqualTo(rhs);}
00092 
00093   bool isValid() const {return m_valid;}
00094 
00096   Quaternion& identity() {m_w = 1; m_vec.zero(); m_valid = true; m_age = 0; return *this;} // Set to null rotation
00097 
00098   // Operators
00099 
00101   Quaternion& operator*= (const Quaternion& rhs);
00103   Quaternion& operator/= (const Quaternion& rhs);
00105   Quaternion operator* (const Quaternion& rhs) const {
00106     Quaternion out(*this);
00107     out *= rhs;
00108     return out;
00109   }
00111   Quaternion operator/ (const Quaternion& rhs) const {
00112     Quaternion out(*this);
00113     out /= rhs;
00114     return out;
00115   }
00116 
00117   // Functions
00118 
00119   // Returns "not_flip", similar to RotMatrix<>.toEuler()
00121 
00130   bool fromRotMatrix(const RotMatrix<3>& m);
00131 
00133   Quaternion inverse() const;
00134 
00136   Quaternion& rotate(const RotMatrix<3>&);
00137 
00139   Quaternion& rotate(const Quaternion& q) {return operator*=(q);}
00140 
00142   Quaternion& rotation(int axis, CoordType angle);
00144   Quaternion& rotation(const Vector<3>& axis, CoordType angle);
00146 
00149   Quaternion& rotation(const Vector<3>& axis); // angle == axis.mag()
00150 
00152   Quaternion& rotation(const Vector<3>& from, const Vector<3>& to);
00153 
00155   CoordType scalar() const              {return m_w;}
00157   const Vector<3>& vector() const       {return m_vec;}
00158 
00160   void normalize();
00162   unsigned age() const {return m_age;}
00163 
00164  private:
00165   Quaternion(bool valid) : m_w(0), m_vec(), m_valid(valid), m_age(1) {}
00166   void checkNormalization() {if(m_age >= WFMATH_MAX_NORM_AGE && m_valid) normalize();}
00167   CoordType m_w;
00168   Vector<3> m_vec;
00169   bool m_valid;
00170   unsigned m_age;
00171 };
00172 
00173 } // namespace WFMath
00174 
00175 #endif  // WFMATH_QUATERNION_H