ossim::Quaternion Class Reference

A quaternion class. More...

#include <ossimQuaternion.h>

Public Types
typedef ossim_float64	value_type

Public Member Functions
	Quaternion ()
	Quaternion (value_type x, value_type y, value_type z, value_type w)
	Quaternion (ossim_float64 angle, const ossimDpt3d &axis)
	Quaternion (ossim_float64 angle, const ossimColumnVector3d &axis)
Quaternion &	operator= (const Quaternion &v)
bool	operator== (const Quaternion &v) const
bool	operator!= (const Quaternion &v) const
bool	operator< (const Quaternion &v) const
void	set (value_type x, value_type y, value_type z, value_type w)
void	set (const ossimMatrix4x4 &matrix)
	Good introductions to Quaternions at: http://www.gamasutra.com/features/programming/19980703/quaternions_01.htm http://mathworld.wolfram.com/Quaternion.html. More...
void	get (ossimMatrix4x4 &matrix) const
value_type &	operator[] (int i)
value_type	operator[] (int i) const
value_type &	x ()
value_type &	y ()
value_type &	z ()
value_type &	w ()
value_type	x () const
value_type	y () const
value_type	z () const
value_type	w () const
bool	zeroRotation () const
	return true if the Quaternion represents a zero rotation, and therefore can be ignored in computations. More...
const Quaternion	operator* (value_type rhs) const
	Multiply by scalar. More...
Quaternion &	operator*= (value_type rhs)
	Unary multiply by scalar. More...
const Quaternion	operator* (const Quaternion &rhs) const
	Binary multiply. More...
Quaternion &	operator*= (const Quaternion &rhs)
	Unary multiply. More...
Quaternion	operator/ (value_type rhs) const
	Divide by scalar. More...
Quaternion &	operator/= (value_type rhs)
	Unary divide by scalar. More...
const Quaternion	operator/ (const Quaternion &denom) const
	Binary divide. More...
Quaternion &	operator/= (const Quaternion &denom)
	Unary divide. More...
const Quaternion	operator+ (const Quaternion &rhs) const
	Binary addition. More...
Quaternion &	operator+= (const Quaternion &rhs)
	Unary addition. More...
const Quaternion	operator- (const Quaternion &rhs) const
	Binary subtraction. More...
Quaternion &	operator-= (const Quaternion &rhs)
	Unary subtraction. More...
const Quaternion	operator- () const
	Negation operator - returns the negative of the quaternion. More...
value_type	length () const
	Length of the quaternion = sqrt( vec . vec ) More...
value_type	length2 () const
	Length of the quaternion = vec . vec. More...
Quaternion	conj () const
	Conjugate. More...
const Quaternion	inverse () const
	Multiplicative inverse method: q^(-1) = q^*/(q.q^*) More...
void	makeRotate (value_type angle, value_type x, value_type y, value_type z)
	Set the elements of the Quat to represent a rotation of angle (radians) around the axis (x,y,z) More...
void	makeRotate (value_type angle, const ossimColumnVector3d &vec)
void	makeRotate (value_type angle, const ossimDpt3d &vec)
void	makeRotate (value_type angle1, const ossimColumnVector3d &axis1, value_type angle2, const ossimColumnVector3d &axis2, value_type angle3, const ossimColumnVector3d &axis3)
void	makeRotate (value_type angle1, const ossimDpt3d &axis1, value_type angle2, const ossimDpt3d &axis2, value_type angle3, const ossimDpt3d &axis3)
void	makeRotate (const ossimColumnVector3d &vec1, const ossimColumnVector3d &vec2)
	Make a rotation Quaternion which will rotate vec1 to vec2. More...
void	makeRotate (const ossimDpt3d &vec1, const ossimDpt3d &vec2)
	Make a rotation Quaternion which will rotate vec1 to vec2. More...
void	getRotate (value_type &angle, value_type &x, value_type &y, value_type &z) const
	Return the angle and vector components represented by the quaternion. More...
void	getRotate (value_type &angle, ossimDpt3d &vec) const
	Return the angle and vector components represented by the quaternion. More...
void	slerp (value_type t, const Quaternion &from, const Quaternion &to)
	Spherical Linear Interpolation. More...
ossimDpt3d	operator* (const ossimDpt3d &v) const
	Rotate a vector by this quaternion. More...

Public Attributes
value_type	theVector [4]

Friends
ossimDpt3d	operator* (const ossimDpt3d &lhs, const ossim::Quaternion &rhs)

Detailed Description

A quaternion class.

It can be used to represent an orientation in 3D space.

Definition at line 13 of file ossimQuaternion.h.

Member Typedef Documentation

value_type

typedef ossim_float64 ossim::Quaternion::value_type

Definition at line 18 of file ossimQuaternion.h.

Constructor & Destructor Documentation

Quaternion() [1/4]

ossim::Quaternion::Quaternion ( )

inline

Definition at line 22 of file ossimQuaternion.h.

        {
           theVector[0]=0.0; theVector[1]=0.0; theVector[2]=0.0; theVector[3]=1.0;
        }

Quaternion() [2/4]

ossim::Quaternion::Quaternion ( value_type  x, value_type  y, value_type  z, value_type  w  )

inline

Definition at line 27 of file ossimQuaternion.h.

References x, and y.

        {
            theVector[0]=x;
            theVector[1]=y;
            theVector[2]=z;
            theVector[3]=w;
        }

Quaternion() [3/4]

ossim::Quaternion::Quaternion ( ossim_float64  angle, const ossimDpt3d &  axis  )

inline

Definition at line 51 of file ossimQuaternion.h.

        {
            makeRotate(angle,axis);
        }

Quaternion() [4/4]

ossim::Quaternion::Quaternion ( ossim_float64  angle, const ossimColumnVector3d &  axis  )

inline

Definition at line 55 of file ossimQuaternion.h.

        {
            makeRotate(angle,axis);
        }

Member Function Documentation

conj()

Quaternion ossim::Quaternion::conj ( ) const

inline

Conjugate.

Definition at line 265 of file ossimQuaternion.h.

        { 
             return Quaternion( -theVector[0], -theVector[1], -theVector[2], theVector[3] );
        }

get()

void ossim::Quaternion::get

(

ossimMatrix4x4 &

matrix

)

const

Definition at line 12 of file ossimQuaternion.cpp.

References ossimMatrix4x4::makeRotate().

{
   matrix.makeRotate(*this);
}

getRotate() [1/2]

void ossim::Quaternion::getRotate	(	value_type &	angle,
		value_type &	x,
		value_type &	y,
		value_type &	z
	)		const

Return the angle and vector components represented by the quaternion.

Angle returned is in degrees.

Definition at line 245 of file ossimQuaternion.cpp.

References ossim::radiansToDegrees(), x, and y.

{
    value_type sinhalfangle = sqrt( theVector[0]*theVector[0] + theVector[1]*theVector[1] + theVector[2]*theVector[2] );

    angle = 2.0 * atan2( sinhalfangle, theVector[3] );
    if(sinhalfangle)
    {
        x = theVector[0] / sinhalfangle;
        y = theVector[1] / sinhalfangle;
        z = theVector[2] / sinhalfangle;
    }
    else
    {
        x = 0.0;
        y = 0.0;
        z = 1.0;
    }
    angle = ossim::radiansToDegrees(angle);
}

getRotate() [2/2]

void ossim::Quaternion::getRotate ( value_type &  angle, ossimDpt3d &  vec  ) const

inline

Return the angle and vector components represented by the quaternion.

Angle returned is in degrees.

Definition at line 325 of file ossimQuaternion.h.

References ossimDpt3d::x, ossimDpt3d::y, and ossimDpt3d::z.

        { getRotate(angle, vec.x, vec.y, vec.z);}

inverse()

const Quaternion ossim::Quaternion::inverse ( ) const

inline

Multiplicative inverse method: q^(-1) = q^*/(q.q^*)

Definition at line 271 of file ossimQuaternion.h.

Referenced by operator/(), and operator/=().

        {
             return conj() / length2();
         }

length()

value_type ossim::Quaternion::length ( ) const

inline

Length of the quaternion = sqrt( vec . vec )

Definition at line 253 of file ossimQuaternion.h.

        {
           return std::sqrt( theVector[0]*theVector[0] + theVector[1]*theVector[1] + theVector[2]*theVector[2] + theVector[3]*theVector[3]);
        }

length2()

value_type ossim::Quaternion::length2 ( ) const

inline

Length of the quaternion = vec . vec.

Definition at line 259 of file ossimQuaternion.h.

Referenced by ossimMatrix4x4::setRotate().

        {
            return theVector[0]*theVector[0] + theVector[1]*theVector[1] + theVector[2]*theVector[2] + theVector[3]*theVector[3];
        }

makeRotate() [1/7]

void ossim::Quaternion::makeRotate	(	value_type	angle,
		value_type	x,
		value_type	y,
		value_type	z
	)

Set the elements of the Quat to represent a rotation of angle (radians) around the axis (x,y,z)

Definition at line 19 of file ossimQuaternion.cpp.

References ossim::degreesToRadians(), x, and y.

Referenced by makeRotate().

{
   
   const value_type epsilon = 0.0000001;
   
   value_type length = sqrt( x*x + y*y + z*z );
   if (length < epsilon)
   {
      // ~zero length axis, so reset rotation to zero.
      *this = ossim::Quaternion();
        return;
    }
   double tempAngle = ossim::degreesToRadians(angle);
   
   value_type inversenorm  = 1.0/length;
   value_type coshalfangle = cos( 0.5*tempAngle );
   value_type sinhalfangle = sin( 0.5*tempAngle );
   
   theVector[0] = x * sinhalfangle * inversenorm;
   theVector[1] = y * sinhalfangle * inversenorm;
   theVector[2] = z * sinhalfangle * inversenorm;
   theVector[3] = coshalfangle;
}

makeRotate() [2/7]

void ossim::Quaternion::makeRotate ( value_type  angle, const ossimColumnVector3d &  vec  )

inline

Definition at line 288 of file ossimQuaternion.h.

        { makeRotate(angle, vec[0], vec[1], vec[2]);}

makeRotate() [3/7]

void ossim::Quaternion::makeRotate ( value_type  angle, const ossimDpt3d &  vec  )

inline

Definition at line 290 of file ossimQuaternion.h.

References ossimDpt3d::x, ossimDpt3d::y, and ossimDpt3d::z.

        { makeRotate(angle, vec.x, vec.y, vec.z);}

makeRotate() [4/7]

void ossim::Quaternion::makeRotate	(	value_type	angle1,
		const ossimColumnVector3d &	axis1,
		value_type	angle2,
		const ossimColumnVector3d &	axis2,
		value_type	angle3,
		const ossimColumnVector3d &	axis3
	)

Definition at line 43 of file ossimQuaternion.cpp.

References makeRotate().

{
    ossim::Quaternion q1; q1.makeRotate(angle1,axis1);
    ossim::Quaternion q2; q2.makeRotate(angle2,axis2);
    ossim::Quaternion q3; q3.makeRotate(angle3,axis3);
    *this = q1*q2*q3;
}                        

makeRotate() [5/7]

void ossim::Quaternion::makeRotate	(	value_type	angle1,
		const ossimDpt3d &	axis1,
		value_type	angle2,
		const ossimDpt3d &	axis2,
		value_type	angle3,
		const ossimDpt3d &	axis3
	)

Definition at line 53 of file ossimQuaternion.cpp.

References makeRotate().

{
   ossim::Quaternion q1; q1.makeRotate(angle1,axis1);
   ossim::Quaternion q2; q2.makeRotate(angle2,axis2);
   ossim::Quaternion q3; q3.makeRotate(angle3,axis3);

    *this = q1*q2*q3;
}                        

makeRotate() [6/7]

void ossim::Quaternion::makeRotate	(	const ossimColumnVector3d &	vec1,
		const ossimColumnVector3d &	vec2
	)

Make a rotation Quaternion which will rotate vec1 to vec2.

Generally take a dot product to get the angle between these and then use a cross product to get the rotation axis Watch out for the two special cases when the vectors are co-incident or opposite in direction.

Definition at line 64 of file ossimQuaternion.cpp.

{
   makeRotate(ossimDpt3d(vec1[0], vec1[1], vec1[2]),
              ossimDpt3d(vec2[0], vec2[1], vec2[2]));
}

makeRotate() [7/7]

void ossim::Quaternion::makeRotate	(	const ossimDpt3d &	from,
		const ossimDpt3d &	to
	)

Make a rotation Quaternion which will rotate vec1 to vec2.

Make a rotation Quat which will rotate vec1 to vec2.

Generally take a dot product to get the angle between these and then use a cross product to get the rotation axis Watch out for the two special cases of when the vectors are co-incident or opposite in direction.

This routine uses only fast geometric transforms, without costly acos/sin computations. It's exact, fast, and with less degenerate cases than the acos/sin method.

For an explanation of the math used, you may see for example: http://logiciels.cnes.fr/MARMOTTES/marmottes-mathematique.pdf

Note

This is the rotation with shortest angle, which is the one equivalent to the acos/sin transform method. Other rotations exists, for example to additionally keep a local horizontal attitude.

Author

Nicolas Brodu

Definition at line 85 of file ossimQuaternion.cpp.

References ossimDpt3d::length2(), ossimDpt3d::x, ossimDpt3d::y, and ossimDpt3d::z.

{

    // This routine takes any vector as argument but normalized 
    // vectors are necessary, if only for computing the dot product.
    // Too bad the API is that generic, it leads to performance loss.
    // Even in the case the 2 vectors are not normalized but same length,
    // the sqrt could be shared, but we have no way to know beforehand
    // at this point, while the caller may know.
    // So, we have to test... in the hope of saving at least a sqrt
    ossimDpt3d sourceVector = from;
    ossimDpt3d targetVector = to;
    
    value_type fromLen2 = from.length2();
    value_type fromLen = 1.0;
    // normalize only when necessary, epsilon test
    if ((fromLen2 < 1.0-1e-7) || (fromLen2 > 1.0+1e-7))
    {
        fromLen = sqrt(fromLen2);
        sourceVector /= fromLen;
    }
    
    value_type toLen2 = to.length2();
    // normalize only when necessary, epsilon test
    if ((toLen2 < 1.0-1e-7) || (toLen2 > 1.0+1e-7))
    {
        value_type toLen;
        // re-use fromLen for case of mapping 2 vectors of the same length
        if ((toLen2 > fromLen2-1e-7) && (toLen2 < fromLen2+1e-7))
        {
            toLen = fromLen;
        } 
        else toLen = sqrt(toLen2);
        targetVector /= toLen;
    }
    
    // Now let's get into the real stuff
    // Use "dot product plus one" as test as it can be re-used later on
    double dotProdPlus1 = 1.0 + sourceVector * targetVector;
    
    // Check for degenerate case of full u-turn. Use epsilon for detection
    if (dotProdPlus1 < 1e-7) {
    
        // Get an orthogonal vector of the given vector
        // in a plane with maximum vector coordinates.
        // Then use it as quaternion axis with pi angle
        // Trick is to realize one value at least is >0.6 for a normalized vector.
        if (fabs(sourceVector.x) < 0.6) {
            const double norm = sqrt(1.0 - sourceVector.x * sourceVector.x);
            theVector[0] = 0.0; 
            theVector[1] = sourceVector.z / norm;
            theVector[2] = -sourceVector.y / norm;
            theVector[3] = 0.0;
        } else if (fabs(sourceVector.y) < 0.6) {
            const double norm = sqrt(1.0 - sourceVector.y * sourceVector.y);
            theVector[0] = -sourceVector.z / norm;
            theVector[1] = 0.0;
            theVector[2] = sourceVector.x / norm;
            theVector[3] = 0.0;
        } else {
            const double norm = sqrt(1.0 - sourceVector.z * sourceVector.z);
            theVector[0] = sourceVector.y / norm;
            theVector[1] = -sourceVector.x / norm;
            theVector[2] = 0.0;
            theVector[3] = 0.0;
        }
    }
    
    else {
        // Find the shortest angle quaternion that transforms normalized vectors
        // into one other. Formula is still valid when vectors are colinear
        const double s = sqrt(0.5 * dotProdPlus1);
        const ossimDpt3d tmp = sourceVector ^ targetVector / (2.0*s);
        theVector[0] = tmp.x;
        theVector[1] = tmp.y;
        theVector[2] = tmp.z;
        theVector[3] = s;
    }
}

operator!=()

bool ossim::Quaternion::operator!= ( const Quaternion &  v ) const

inline

Definition at line 89 of file ossimQuaternion.h.

References theVector.

{ return theVector[0]!=v.theVector[0] || theVector[1]!=v.theVector[1] || theVector[2]!=v.theVector[2] || theVector[3]!=v.theVector[3]; }

operator*() [1/3]

const Quaternion ossim::Quaternion::operator* ( value_type  rhs ) const

inline

Multiply by scalar.

Definition at line 141 of file ossimQuaternion.h.

        {
            return Quaternion(theVector[0]*rhs, theVector[1]*rhs, theVector[2]*rhs, theVector[3]*rhs);
        }

operator*() [2/3]

const Quaternion ossim::Quaternion::operator* ( const Quaternion &  rhs ) const

inline

Binary multiply.

Definition at line 157 of file ossimQuaternion.h.

References theVector.

        {
            return Quaternion( rhs.theVector[3]*theVector[0] + rhs.theVector[0]*theVector[3] + rhs.theVector[1]*theVector[2] - rhs.theVector[2]*theVector[1],
                 rhs.theVector[3]*theVector[1] - rhs.theVector[0]*theVector[2] + rhs.theVector[1]*theVector[3] + rhs.theVector[2]*theVector[0],
                 rhs.theVector[3]*theVector[2] + rhs.theVector[0]*theVector[1] - rhs.theVector[1]*theVector[0] + rhs.theVector[2]*theVector[3],
                 rhs.theVector[3]*theVector[3] - rhs.theVector[0]*theVector[0] - rhs.theVector[1]*theVector[1] - rhs.theVector[2]*theVector[2] );
        }

operator*() [3/3]

ossimDpt3d ossim::Quaternion::operator* ( const ossimDpt3d &  v ) const

inline

Rotate a vector by this quaternion.

Definition at line 333 of file ossimQuaternion.h.

        {
            // nVidia SDK implementation
            ossimDpt3d uv, uuv; 
            ossimDpt3d qvec(theVector[0], theVector[1], theVector[2]);
            uv = qvec ^ v;
            uuv = qvec ^ uv; 
            uv *= ( 2.0f * theVector[3] ); 
            uuv *= 2.0f; 
            return v + uv + uuv;
        }

operator*=() [1/2]

Quaternion& ossim::Quaternion::operator*= ( value_type  rhs )

inline

Unary multiply by scalar.

Definition at line 147 of file ossimQuaternion.h.

        {
            theVector[0]*=rhs;
            theVector[1]*=rhs;
            theVector[2]*=rhs;
            theVector[3]*=rhs;
            return *this;        // enable nesting
        }

operator*=() [2/2]

Quaternion& ossim::Quaternion::operator*= ( const Quaternion &  rhs )

inline

Unary multiply.

Definition at line 166 of file ossimQuaternion.h.

References theVector, x, and y.

        {
            value_type x = rhs.theVector[3]*theVector[0] + rhs.theVector[0]*theVector[3] + rhs.theVector[1]*theVector[2] - rhs.theVector[2]*theVector[1];
            value_type y = rhs.theVector[3]*theVector[1] - rhs.theVector[0]*theVector[2] + rhs.theVector[1]*theVector[3] + rhs.theVector[2]*theVector[0];
            value_type z = rhs.theVector[3]*theVector[2] + rhs.theVector[0]*theVector[1] - rhs.theVector[1]*theVector[0] + rhs.theVector[2]*theVector[3];
            theVector[3]   = rhs.theVector[3]*theVector[3] - rhs.theVector[0]*theVector[0] - rhs.theVector[1]*theVector[1] - rhs.theVector[2]*theVector[2];

            theVector[2] = z;
            theVector[1] = y;
            theVector[0] = x;

            return (*this);            // enable nesting
        }

operator+()

const Quaternion ossim::Quaternion::operator+ ( const Quaternion &  rhs ) const

inline

Binary addition.

Definition at line 212 of file ossimQuaternion.h.

References theVector.

        {
            return Quaternion(theVector[0]+rhs.theVector[0], theVector[1]+rhs.theVector[1],
                theVector[2]+rhs.theVector[2], theVector[3]+rhs.theVector[3]);
        }

operator+=()

Quaternion& ossim::Quaternion::operator+= ( const Quaternion &  rhs )

inline

Unary addition.

Definition at line 219 of file ossimQuaternion.h.

References theVector.

        {
            theVector[0] += rhs.theVector[0];
            theVector[1] += rhs.theVector[1];
            theVector[2] += rhs.theVector[2];
            theVector[3] += rhs.theVector[3];
            return *this;            // enable nesting
        }

operator-() [1/2]

const Quaternion ossim::Quaternion::operator- ( const Quaternion &  rhs ) const

inline

Binary subtraction.

Definition at line 229 of file ossimQuaternion.h.

References theVector.

        {
            return Quaternion(theVector[0]-rhs.theVector[0], theVector[1]-rhs.theVector[1],
                theVector[2]-rhs.theVector[2], theVector[3]-rhs.theVector[3] );
        }

operator-() [2/2]

const Quaternion ossim::Quaternion::operator- ( ) const

inline

Negation operator - returns the negative of the quaternion.

Basically just calls operator - () on the Vec4

Definition at line 247 of file ossimQuaternion.h.

        {
            return Quaternion (-theVector[0], -theVector[1], -theVector[2], -theVector[3]);
        }

operator-=()

Quaternion& ossim::Quaternion::operator-= ( const Quaternion &  rhs )

inline

Unary subtraction.

Definition at line 236 of file ossimQuaternion.h.

References theVector.

        {
            theVector[0]-=rhs.theVector[0];
            theVector[1]-=rhs.theVector[1];
            theVector[2]-=rhs.theVector[2];
            theVector[3]-=rhs.theVector[3];
            return *this;            // enable nesting
        }

operator/() [1/2]

Quaternion ossim::Quaternion::operator/ ( value_type  rhs ) const

inline

Divide by scalar.

Definition at line 181 of file ossimQuaternion.h.

        {
            value_type div = 1.0/rhs;
            return Quaternion(theVector[0]*div, theVector[1]*div, theVector[2]*div, theVector[3]*div);
        }

operator/() [2/2]

const Quaternion ossim::Quaternion::operator/ ( const Quaternion &  denom ) const

inline

Binary divide.

Definition at line 199 of file ossimQuaternion.h.

References inverse().

        {
            return ( (*this) * denom.inverse() );
        }

operator/=() [1/2]

Quaternion& ossim::Quaternion::operator/= ( value_type  rhs )

inline

Unary divide by scalar.

Definition at line 188 of file ossimQuaternion.h.

        {
            value_type div = 1.0/rhs;
            theVector[0]*=div;
            theVector[1]*=div;
            theVector[2]*=div;
            theVector[3]*=div;
            return *this;
        }

operator/=() [2/2]

Quaternion& ossim::Quaternion::operator/= ( const Quaternion &  denom )

inline

Unary divide.

Definition at line 205 of file ossimQuaternion.h.

References inverse().

        {
            (*this) = (*this) * denom.inverse();
            return (*this);            // enable nesting
        }

operator<()

bool ossim::Quaternion::operator< ( const Quaternion &  v ) const

inline

Definition at line 91 of file ossimQuaternion.h.

References theVector.

        {
            if (theVector[0]<v.theVector[0]) return true;
            else if (theVector[0]>v.theVector[0]) return false;
            else if (theVector[1]<v.theVector[1]) return true;
            else if (theVector[1]>v.theVector[1]) return false;
            else if (theVector[2]<v.theVector[2]) return true;
            else if (theVector[2]>v.theVector[2]) return false;
            else return (theVector[3]<v.theVector[3]);
        }

operator=()

Quaternion& ossim::Quaternion::operator= ( const Quaternion &  v )

inline

Definition at line 78 of file ossimQuaternion.h.

References theVector.

           {
              theVector[0]=v.theVector[0];
              theVector[1]=v.theVector[1];
              theVector[2]=v.theVector[2];
              theVector[3]=v.theVector[3];
              return *this;
           }

operator==()

bool ossim::Quaternion::operator== ( const Quaternion &  v ) const

inline

Definition at line 87 of file ossimQuaternion.h.

References theVector.

{ return theVector[0]==v.theVector[0] && theVector[1]==v.theVector[1] && theVector[2]==v.theVector[2] && theVector[3]==v.theVector[3]; }

operator[]() [1/2]

value_type& ossim::Quaternion::operator[] ( int  i )

inline

Definition at line 116 of file ossimQuaternion.h.

{ return theVector[i]; }

operator[]() [2/2]

value_type ossim::Quaternion::operator[] ( int  i ) const

inline

Definition at line 117 of file ossimQuaternion.h.

{ return theVector[i]; }

set() [1/2]

void ossim::Quaternion::set ( value_type  x, value_type  y, value_type  z, value_type  w  )

inline

Definition at line 103 of file ossimQuaternion.h.

References x, and y.

        {
            theVector[0]=x;
            theVector[1]=y;
            theVector[2]=z;
            theVector[3]=w;
        }

set() [2/2]

void ossim::Quaternion::set

(

const ossimMatrix4x4 &

matrix

)

Good introductions to Quaternions at: http://www.gamasutra.com/features/programming/19980703/quaternions_01.htm http://mathworld.wolfram.com/Quaternion.html.

Definition at line 7 of file ossimQuaternion.cpp.

References ossimMatrix4x4::getRotate().

{
   matrix.getRotate(*this);
}

slerp()

void ossim::Quaternion::slerp	(	value_type	t,
		const Quaternion &	from,
		const Quaternion &	to
	)

Spherical Linear Interpolation.

As it goes from 0 to 1, the Quaternion object goes from "from" to "to".

w() [1/2]

value_type& ossim::Quaternion::w ( )

inline

Definition at line 122 of file ossimQuaternion.h.

{ return theVector[3]; }

w() [2/2]

value_type ossim::Quaternion::w ( ) const

inline

Definition at line 127 of file ossimQuaternion.h.

{ return theVector[3]; }

x() [1/2]

value_type& ossim::Quaternion::x ( )

inline

Definition at line 119 of file ossimQuaternion.h.

{ return theVector[0]; }

x() [2/2]

value_type ossim::Quaternion::x ( ) const

inline

Definition at line 124 of file ossimQuaternion.h.

{ return theVector[0]; }

y() [1/2]

value_type& ossim::Quaternion::y ( )

inline

Definition at line 120 of file ossimQuaternion.h.

{ return theVector[1]; }

y() [2/2]

value_type ossim::Quaternion::y ( ) const

inline

Definition at line 125 of file ossimQuaternion.h.

{ return theVector[1]; }

z() [1/2]

value_type& ossim::Quaternion::z ( )

inline

Definition at line 121 of file ossimQuaternion.h.

{ return theVector[2]; }

z() [2/2]

value_type ossim::Quaternion::z ( ) const

inline

Definition at line 126 of file ossimQuaternion.h.

{ return theVector[2]; }

zeroRotation()

bool ossim::Quaternion::zeroRotation ( ) const

inline

return true if the Quaternion represents a zero rotation, and therefore can be ignored in computations.

Definition at line 130 of file ossimQuaternion.h.

{ return theVector[0]==0.0 && theVector[1]==0.0 && theVector[2]==0.0 && theVector[3]==1.0; } 

Friends And Related Function Documentation

operator*

ossimDpt3d operator* ( const ossimDpt3d &  lhs, const ossim::Quaternion &  rhs  )

friend

Definition at line 344 of file ossimQuaternion.h.

        {
           ossimDpt3d uv, uuv; 
           ossimDpt3d qvec(rhs.theVector[0], rhs.theVector[1], rhs.theVector[2]);
           uv = qvec ^ lhs;
           uuv = qvec ^ uv; 
           uv *= ( 2.0f * rhs.theVector[3] ); 
           uuv *= 2.0f;
           
           return lhs + uv + uuv;
        }

Member Data Documentation

theVector

value_type ossim::Quaternion::theVector[4]

Definition at line 20 of file ossimQuaternion.h.

Referenced by operator!=(), operator*(), operator*=(), operator+(), operator+=(), operator-(), operator-=(), operator<(), operator=(), and operator==().

---

The documentation for this class was generated from the following files:

• ossimQuaternion.h
• ossimQuaternion.cpp