---

quat.H

Go to the documentation of this file.

/*
 * Copyright 2000, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#ifndef QUAT_HEADER
#define QUAT_HEADER

#include "std/config.H"
#include "mlib/global.H"

template <class QUAT, class T, class P, class V, class L>
class _quat
{
protected:
   V            _v;
   Greal       _w;
   
public:
   
   _quat() : _v(), _w(1) {}
   _quat(const V& v, Greal w)  : _v(v), _w(w) {}
   _quat(Greal w)   : _w(w) {}
   _quat(const V& v) : _v(v), _w(0) {}
   
   //create quaternion from rotation matrix
   _quat(const T& t);
   
   //create quaternion to rotate from v1 to v2
   _quat(const V& v1, const V& v2);
   
   const V&     v()  const              { return _v; }
   V&           v()                     { return _v; }
   Greal       w()  const              { return _w; }
   Greal&      w()                     { return _w; }

   Greal       norm()      const       { return _v.lengthSqrd() + _w*_w; }

   QUAT         conjugate() const       { return QUAT(-_v, _w); }
   QUAT         inverse()   const       { return conjugate()/norm(); }
   
   QUAT         operator+(QUAT q) const { return QUAT(v()+q.v(), w()+q.w()); }
   QUAT         operator*(QUAT q) const { return QUAT(cross(v(), q.v()) 
                                                       + w()*q.v() + q.w()*v(), 
                                                      w()*q.w() - v()*q.v()); } 
   QUAT         operator/(QUAT q) const { return operator*(q.inverse()); }

   static QUAT  slerp(const QUAT& q1, const QUAT& q2, Greal u);
}; 

template <class QUAT, class T, class P, class V, class L>
inline ostream &
operator<<(ostream &os, const _quat<QUAT,T,P,V,L> &p) 
{ 
   return os << "<" << p.v() << ", " << p.w() << ">";
}

#ifdef GLUE_NEEDS_TEMPLATES_IN_H_FILE
#include "quat.C"
#endif
#endif

---