+ View the NASA Portal

Search JPL

Search CLARAty

- Algorithms- Infrastructure - Doxygen (public)- Doxygen (private)- Tutorials

- Repository- Nightly Build- Nightly Regression- Feature/Bug Tracking- Build Targets- Procedure- Conventions- Tools

claraty::Quaternion< T > Class Template Reference

#include <quaternion.h>

Inheritance diagram for claraty::Quaternion< T >:

[legend]Collaboration diagram for claraty::Quaternion< T >:

[legend]List of all members.

Public Member Functions
	Quaternion ()
	Quaternion (const T *array)
	Quaternion (const Vector< T > &v)
	Quaternion (const T &r, const T &p, const T &y)
	Quaternion (const T &scalar_1, const T &scalar_2, const T &scalar_3, const T &scalar_4)
	Quaternion (ROTATION_TYPE type, const T &r, const T &p=T(), const T &y=T())
	Quaternion (const Quaternion &q)
	Quaternion (const Base_Quaternion< T > &q)
	Quaternion (const RMatrix< T > &m)
	Quaternion (const Vector< T > &a, const Vector< T > &b)
	Quaternion (const Vector< T > &euler_vector, const T &euler_angle)
	~Quaternion ()
T &	operator() (int n)
const T &	operator() (int n) const
Quaternion	operator= (const Quaternion &rhs)
Quaternion	operator= (const RMatrix< T > &rhs)
Quaternion	operator * (const Quaternion &rhs) const
Point< T >	operator * (const Point< T > &rhs) const
Quaternion	operator/ (const Quaternion &rhs)
bool	operator== (const Quaternion &rhs) const
void	rotation_matrix_to_quaternion (const RMatrix< T > &m)
RMatrix< T >	quaternion_to_rotation_matrix () const
RMatrix< T >	get_rotation_matrix () const
Vector< T >	quaternion_to_theta_triple () const
void	theta_triple_to_quaternion (const Vector< T > &a)
void	euler_parameters_to_quaternion (const Vector< T > &euler_vector, const T &euler_angle)
T	get_euler_angle ()
T	norm () const
void	conjugate ()
void	negate ()
Quaternion	interpolate (const T &k, Quaternion &a) const
void	scale (const T &d)
void	normalize ()
void	power (const T &p)
void	standardize ()
void	set_identity ()
bool	io (FDM_Map map)
Quaternion	reverse ()
Vector< T >	get_x_axis () const
Vector< T >	get_y_axis () const
Vector< T >	get_z_axis () const
void	get_rpy_angles (T &roll, T &pitch, T &yaw) const
Public Attributes
T	_elements [4]
Static Public Attributes
static const Base_Quaternion< T >	identity
Friends
template<class Y>
std::ostream &	operator<< (std::ostream &os, const Quaternion< Y > &q)

---

Detailed Description

template<class T>
class claraty::Quaternion< T >

Definition at line 64 of file quaternion.h.

---

Constructor & Destructor Documentation

template<class T>

claraty::Quaternion< T >::Quaternion

(

)

[inline]

Definition at line 73 of file quaternion.h.

: Base_Quaternion<T>(identity) {}

template<class T>

claraty::Quaternion< T >::Quaternion

(

const T *

array

)

This constructor copies an input array of T into its elements.

Definition at line 163 of file quaternion.h.

References EPSILON, and claraty::Quaternion< T >::norm().

{
  assert(this->_elements != NULL);

  // Copy the data from array to this quaternion
  for (int i=0; i<4; i++)
    this->_elements[i] = array[i];

  // Check for consistancy of elements
  assert(norm() - 1.0 < EPSILON);
}

Here is the call graph for this function:

template<class T>

claraty::Quaternion< T >::Quaternion

(

const Vector< T > &

a

)

This constructor creates a quaternion with the rotation transformation corresponding to the rotation represented by three angles about the X-, Y- and Z- axes.

Definition at line 181 of file quaternion.h.

References claraty::Quaternion< T >::theta_triple_to_quaternion().

{
  // cout <<
  // "Quaternion constructor Quaternion(Vector<T> & a)"
  // << endl;

  assert(this->_elements != NULL);

  theta_triple_to_quaternion(a);

}

Here is the call graph for this function:

template<class T>

claraty::Quaternion< T >::Quaternion	(	const T &	r,
		const T &	p,
		const T &	y
	)

template<class T>

claraty::Quaternion< T >::Quaternion	(	const T &	scalar_1,
		const T &	scalar_2,
		const T &	scalar_3,
		const T &	scalar_4
	)

This constructor creates a quaternion with elements set to equal to the 4 input parameters.

Definition at line 236 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements.

{
  // cout <<
  // "Quaternion constructor Quaternion(const T& scalar_1, const T& scalar_2, const T& scalar_3, const T& scalar_4)"
  // << endl;

  assert(this->_elements != NULL);

  // Initialize the zero transformation quaternion
  this->_elements[0] = scalar_1;
  this->_elements[1] = scalar_2;
  this->_elements[2] = scalar_3;
  this->_elements[3] = scalar_4;

  // Don't normalize because the entered values may intentionally not represent a
  // unit quaternion
  // normalize();

}

template<class T>

claraty::Quaternion< T >::Quaternion	(	ROTATION_TYPE	type,
		const T &	r,
		const T &	p = T(),
		const T &	y = T()
	)

This constructor creates a quaternion with elements set to equal to the 4 input parameters.

Definition at line 197 of file quaternion.h.

References claraty::ANGLE_AXIS, claraty::EULER_ZYZ, claraty::RPY, claraty::RX, claraty::RY, and claraty::RZ.

{
  // cout <<
  // "Quaternion constructor Quaternion(const T& scalar_1, const T& scalar_2, const T& scalar_3, const T& scalar_4)"
  // << endl;

  assert(this->_elements != NULL);
  
  //RMatrix<T> temp(type, r, p, y);
  //*this = Quaternion<T>(temp);

  RMatrix<T> temp;
  
  switch(type) {
    
  case RX:
  case RY:
  case RZ:
    temp = RMatrix<T>(type, r );
    break;
    
    
  case EULER_ZYZ:     // Rotation about rotated axes Z, Y, Z
  case RPY:           // Rotation about fixed axes X, Y, Z
  case ANGLE_AXIS:    // Angle-axis rotation about X, Y, Z axes
    temp = RMatrix<T>(type, r, p, y);
    break;
    
  default:
    std::cout << "rotation matrix error: undefined matrix type" << std::endl;
  }
  *this = Quaternion<T>(temp);
}

template<class T>

claraty::Quaternion< T >::Quaternion

(

const Quaternion< T > &

q

)

This is a copy constructor

Definition at line 260 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements.

{
  // cout << "Quaternion constructor Quaternion(const Quaternion& q)" << endl;

  assert(this->_elements != NULL);

  // Initialize this quaternion to be equal to the input quaternion
  for (int i=0; i<4; i++)
     this->_elements[i] = q._elements[i];

}

template<class T>

claraty::Quaternion< T >::Quaternion

(

const Base_Quaternion< T > &

q

)

[inline]

Definition at line 82 of file quaternion.h.

: Base_Quaternion<T>(q) {}

template<class T>

claraty::Quaternion< T >::Quaternion

(

const RMatrix< T > &

m

)

This constructor creates a quaternion that represents the rotation transformation specified in the input rotation matrix.

Definition at line 276 of file quaternion.h.

References claraty::Quaternion< T >::rotation_matrix_to_quaternion().

{
  // cout << "Quaternion constructor Quaternion(const RMatrix& m)" << endl;

  assert(this->_elements != NULL);

  rotation_matrix_to_quaternion(m);
}

Here is the call graph for this function:

template<class T>

claraty::Quaternion< T >::Quaternion	(	const Vector< T > &	a,
		const Vector< T > &	b
	)

This constructor creates the quaternion corresponding to the rotation of a 3-D vector a to a 3-D vector b.

Definition at line 290 of file quaternion.h.

References claraty::Vector< T >::cross(), claraty::Vector< T >::dot(), claraty::Quaternion< T >::euler_parameters_to_quaternion(), M_PI, claraty::Vector< T >::magnitude(), and claraty::Quaternion< T >::set_identity().

{
  if (a == b)
    {
      set_identity();
      return;
    }
  // make copies because a and b are consts
  Vector<T> a_copy(a);
  Vector<T> b_copy(b);
  Vector<T> b_copy_neg(Point<T>(-b(0), -b(1), -b(2)));
  
  assert(this->_elements != NULL);

  // Make sure that the input vectors are not of zero magnitude and have
  // 3 elements
  assert(a_copy.magnitude() != 0.0);
  assert(b_copy.magnitude() != 0.0);
  assert(a_copy.size() == 3);
  assert(b_copy.size() == 3);

  // Normalize the vectors -- cannot use fnorm for now because it
  // appears to be incorrect
  T norm_a = sqrt(a_copy.dot(a_copy));
  T norm_b = sqrt(b_copy.dot(b_copy));
  T norm_b_neg = sqrt(b_copy_neg.dot(b_copy_neg));
  a_copy /= norm_a;
  b_copy /= norm_b;
  b_copy_neg /= norm_b_neg;

  //std::cout << "a_copy " << a_copy << std::endl;
  //std::cout << "b_copy " << b_copy << std::endl;

  Vector<T> euler_vector(3);

  //Handle special case when vectors are aligned
  T euler_angle;

  // If vectors point in the same direction
  if (a_copy == b_copy)
    {
      // The euler angle is zero so it doesn't matter what the euler
      // vector is
      euler_vector = Vector<T>(Point<T>(1.0, 0.0, 0.0)); 
      euler_angle  = 0;
    }
  // if vectors point in oposite directions
  else if (a_copy == b_copy_neg)
    {
      // Arbitrarily choose (1.0, 0.0, 0.0) and see if it is
      // perpendicular to a_copy
      if (a_copy.dot(Vector<T>(Point<T>(1.0, 0.0, 0.0))) == 0.0)
        euler_vector = Vector<T>(Point<T>(1.0, 0.0, 0.0));

      // else try (0.0, 1.0, 0.0)
      else if (a_copy.dot(Vector<T>(Point<T>(0.0, 1.0, 0.0))) == 0.0)
        euler_vector = Vector<T>(Point<T>(0.0, 1.0, 0.0));

      // else try (0.0, 0.0, 1.0)
      else if (a_copy.dot(Vector<T>(Point<T>(0.0, 0.0, 1.0))) == 0.0)
        euler_vector = Vector<T>(Point<T>(0.0, 0.0, 1.0));

      else // use a random vector that's perpendicular to a_copy
        euler_vector = a_copy.cross(Vector<T>(Point<T>(0.4243, 0.5657, 0.7071)));

      euler_angle  = M_PI;
    }
  else  // the vectors are not aligned; choose the euler vector and
        // angle from the minimum rotation of the first vector to the second
    {
      // Get the Euler vector by performing the cross product between a
      // and b
      euler_vector = a_copy.cross(b_copy);
      // Get the Euler angle from the dot product and cross product 
      euler_angle = atan2(euler_vector.magnitude(), a_copy.dot(b_copy));
    }

  std::cout << "euler_vector = " << euler_vector << std::endl;
  std::cout << "eular_angle =  " << euler_angle  << std::endl;
  
  euler_parameters_to_quaternion(euler_vector, euler_angle);

}

Here is the call graph for this function:

template<class T>

claraty::Quaternion< T >::Quaternion	(	const Vector< T > &	euler_vector,
		const T &	euler_angle
	)

This constructor creates the quaternion corresponding to the input Euler vector and Euler angle inputs. The Euler angle is assumed to be in units of radians.

Definition at line 380 of file quaternion.h.

References claraty::Quaternion< T >::euler_parameters_to_quaternion().

{
  // cout <<
  //   "Quaternion constructor Quaternion(const Vector<T>& euler_vector, const T& euler_angle)"
  //     << endl;

  assert(this->_elements != NULL);

  euler_parameters_to_quaternion(euler_vector, euler_angle);
}

Here is the call graph for this function:

template<class T>

claraty::Quaternion< T >::~Quaternion

(

)

[inline]

Definition at line 86 of file quaternion.h.

{};

---

Member Function Documentation

template<class T>

T& claraty::Quaternion< T >::operator()

(

int

n

)

[inline]

Definition at line 90 of file quaternion.h.

{return this->_elements[n];}

template<class T>

const T& claraty::Quaternion< T >::operator()

(

int

n

)

const [inline]

Definition at line 91 of file quaternion.h.

{return this->_elements[n];}

template<class T>

Quaternion< T > claraty::Quaternion< T >::operator=

(

const Quaternion< T > &

rhs

)

This is the equals operator. The left hand side is set equals to the right hand side.

Definition at line 399 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements.

{
  // If the lhs is already the rhs, return the lhs
  if (this == &rhs) return *this;
  
  // Copy the elements of the rhs to the lhs
  memcpy(this->_elements, rhs._elements, sizeof(T)*4);

  return *this;
}

template<class T>

Quaternion< T > claraty::Quaternion< T >::operator=

(

const RMatrix< T > &

rhs

)

This is the equals operator. The left hand side is set equals to the right hand side.

Definition at line 415 of file quaternion.h.

References claraty::Quaternion< T >::rotation_matrix_to_quaternion().

{
  // Copy the elements of the rhs to the lhs
  rotation_matrix_to_quaternion(rhs);

  return *this;
}

Here is the call graph for this function:

template<class T>

Quaternion< T > claraty::Quaternion< T >::operator *

(

const Quaternion< T > &

rhs

)

const

This is the product operator.

Definition at line 427 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements.

{
  Quaternion<T> temp;
  
  temp._elements[0] =   this->_elements[3] * rhs._elements[0] + 
                      - this->_elements[2] * rhs._elements[1] +
                        this->_elements[1] * rhs._elements[2] +
                        this->_elements[0] * rhs._elements[3];
  
  temp._elements[1] =   this->_elements[2] * rhs._elements[0] +
                        this->_elements[3] * rhs._elements[1] +
                      - this->_elements[0] * rhs._elements[2] +
                        this->_elements[1] * rhs._elements[3];

  temp._elements[2] = - this->_elements[1] * rhs._elements[0] +
                        this->_elements[0] * rhs._elements[1] +
                        this->_elements[3] * rhs._elements[2] +
                        this->_elements[2] * rhs._elements[3];

  temp._elements[3] = - this->_elements[0] * rhs._elements[0] +
                      - this->_elements[1] * rhs._elements[1] +
                      - this->_elements[2] * rhs._elements[2] +
                        this->_elements[3] * rhs._elements[3];

  return temp;
}

template<class T>

Point< T > claraty::Quaternion< T >::operator *

(

const Point< T > &

rhs

)

const

Definition at line 458 of file quaternion.h.

References claraty::Quaternion< T >::conjugate(), and claraty::Point< T >::xyz().

{
  Quaternion<T> q_temp1(rhs(0), rhs(1), rhs(2), 0.0);
  Quaternion<T> q_temp2(*this);
  Quaternion<T> q_temp3;
  Point<T> ret_val(0.0, 0.0, 0.0);

  q_temp2.conjugate();
  q_temp3 = (*this) * q_temp1 * q_temp2;
  ret_val.xyz(q_temp3(0), q_temp3(1),q_temp3(2));
  
  //  p(0) = lhs._data[0][0]*rhs(0) + lhs._data[0][1]*rhs(1) + lhs._data[0][2]*rhs(2);
  //  p(1) = lhs._data[1][0]*rhs(0) + lhs._data[1][1]*rhs(1) + lhs._data[1][2]*rhs(2);
  //  p(2) = lhs._data[2][0]*rhs(0) + lhs._data[2][1]*rhs(1) + lhs._data[2][2]*rhs(2);
  return ret_val;
}

Here is the call graph for this function:

template<class T>

Quaternion< T > claraty::Quaternion< T >::operator/

(

const Quaternion< T > &

rhs

)

This is the divide operator.

Definition at line 478 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements, claraty::Quaternion< T >::conjugate(), and claraty::Quaternion< T >::negate().

{
  Quaternion<T> temp1(*this), temp2, temp3;
  
  temp2 = rhs;
  temp2.conjugate();
  temp3 = temp1 * temp2;
  if (temp3._elements[3] < 0.0)
    temp3.negate();
  return temp3;
}

Here is the call graph for this function:

template<class T>

bool claraty::Quaternion< T >::operator==

(

const Quaternion< T > &

rhs

)

const

This is the test equals operator. If the elements of the left hand side are equal to the elements of the right hand side, return TRUE, otherwise return FALSE

Definition at line 495 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements.

{
  // If the lhs is the rhs, return 0
  if (this == &rhs) return true;
  
  for (int i=0; i<4; i++)
    if (this->_elements[i] != rhs._elements[i])
      return false;

  return true;
}

template<class T>

void claraty::Quaternion< T >::rotation_matrix_to_quaternion

(

const RMatrix< T > &

m

)

This operation determines the quaternion that performs a transformation that is equivalent to the transformation performed by its input rotation matrix. The equivalent quaternion is put in this quaternion.

Definition at line 524 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements, and claraty::Quaternion< T >::negate().

Referenced by claraty::Quaternion< T >::operator=(), and claraty::Quaternion< T >::Quaternion().

{
  int i, f, g;
  T ta, k, prd[4][4];

  // Compute porduct of terms of addition
  prd[0][1] = prd[1][0] = (T)(m(1,0) + m(0,1));
  prd[1][2] = prd[2][1] = (T)(m(2,1) + m(1,2));
  prd[2][0] = prd[0][2] = (T)(m(0,2) + m(2,0));
  prd[0][3] = prd[3][0] = (T)(m(2,1) - m(1,2));
  prd[1][3] = prd[3][1] = (T)(m(0,2) - m(2,0));
  prd[2][3] = prd[3][2] = (T)(m(1,0) - m(0,1));

  // Determine which form to use */
  if ((ta=(T)( m(0,0)+m(1,1)+m(2,2))) >= 0.0 )
    f=3;
  else if ((ta=(T)( m(0,0)-m(1,1)-m(2,2))) >= 0.0 )
    f=0;
  else if ((ta=(T)(-m(0,0)+m(1,1)-m(2,2))) >= 0.0 )
    f=1;
  else
  {
    ta=(T)(-m(0,0)-m(1,1)+m(2,2));
    f=2;
  }

  // Determine other parts
  ta = (T)(0.5 * sqrt(1.0 + ta ));
  this->_elements[f] = ta;
  k = 0.25 / this->_elements[f];
  for ( i=0, g=(f+1)&3; i<3; ++i, g=(g+1)&3 )
    this->_elements[g] = k * prd[f][g];
  
  if ( this->_elements[3] < 0.0 )
    negate();
}

Here is the call graph for this function:

template<class T>

RMatrix< T > claraty::Quaternion< T >::quaternion_to_rotation_matrix

(

)

const

This operation returns the rotation matrix equivalent of the quaternion.

Definition at line 565 of file quaternion.h.

References claraty::Quaternion< T >::norm().

Referenced by claraty::Quaternion< T >::get_rpy_angles(), claraty::Quaternion< double >::get_x_axis(), claraty::Quaternion< double >::get_y_axis(), claraty::Quaternion< double >::get_z_axis(), and claraty::RMatrix< T >::RMatrix().

{
  int i, j;
  T k, k2, qq[4][4], t;
  RMatrix<T> a;

  // Form partial products
  for ( i=0; i<4; i++ )
    for ( j=0; j<4; j++ )
      qq[i][j] = this->_elements[i] * this->_elements[j];

  // Fill rotation matrix
  t = norm();
  k = 1.0 / (t*t);
  k2 = 2.0 * k;
  a(0,0) = k * (  qq[0][0] - qq[1][1] - qq[2][2] + qq[3][3]);
  a(1,1) = k * ( -qq[0][0] + qq[1][1] - qq[2][2] + qq[3][3]);
  a(2,2) = k * ( -qq[0][0] - qq[1][1] + qq[2][2] + qq[3][3]);
  a(1,0) = k2 * ( qq[0][1] + qq[2][3] );
  a(0,1) = k2 * ( qq[0][1] - qq[2][3] );
  a(2,0) = k2 * ( qq[0][2] - qq[1][3] );
  a(0,2) = k2 * ( qq[0][2] + qq[1][3] );
  a(2,1) = k2 * ( qq[1][2] + qq[0][3] );
  a(1,2) = k2 * ( qq[1][2] - qq[0][3] );

  return a;
}

Here is the call graph for this function:

template<class T>

RMatrix<T> claraty::Quaternion< T >::get_rotation_matrix

(

)

const

template<class T>

Vector< T > claraty::Quaternion< T >::quaternion_to_theta_triple

(

)

const

Form the quaternion corresponding to the rotation represented by a vector of 3 rotation angles about the X-, Y- and Z-axes.

Definition at line 782 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements.

{
  double s,k,l,t;
  Vector<T> a(3);
  
  s = sqrt( this->_elements[0]*this->_elements[0] +
            this->_elements[1]*this->_elements[1] +
            this->_elements[2]*this->_elements[2] );
  l = (s != 0.0 ? atan2(s, (double)this->_elements[3] ) : 0.0);
  
  if (s!=0.0)
    k = l * 2.0 / s;
  else
    k = 0.0;
 
  t = this->_elements[0] * k;
  a(0) = t;
  t = this->_elements[1] * k;
  a(1) = t;
  t = this->_elements[2] * k;
  a(2) = t;
  
  return a;
}

template<class T>

void claraty::Quaternion< T >::theta_triple_to_quaternion

(

const Vector< T > &

a

)

Form the quaternion corresponding to the rotation represented by a vector of 3 rotation angles about the X-, Y- and Z-axes.

Definition at line 761 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements.

Referenced by claraty::Quaternion< T >::Quaternion().

{
  double s,k,l;
  
  k = sqrt(a(0)*a(0) + a(1)*a(1) + a(2)*a(2));
  l = 0.5 * k;
  s = (k!=0.0 ? sin(l)/k : 0.0);
  
  // a.scale(s);
  // The scale function is currently not implemented in the vector
  // class so we do it here.
  this->_elements[0] = s * a(0);
  this->_elements[1] = s * a(1);
  this->_elements[2] = s * a(2);
  this->_elements[3] = cos(l);
}

template<class T>

void claraty::Quaternion< T >::euler_parameters_to_quaternion	(	const Vector< T > &	euler_vector,
		const T &	euler_angle
	)

This operation makes this quaternion correspond to the entered Euler vector and angle

Definition at line 597 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements.

Referenced by claraty::Quaternion< T >::Quaternion().

{
  T theta_2 = euler_angle / 2.0;
  int i;

  this->_elements[3] = (T) cos((double)theta_2);

  // The vector that was entered may not be normalized so
  // normalize it

  T normVec = (T)sqrt((double)(euler_vector[0]*euler_vector[0]
                               + euler_vector[1]*euler_vector[1]
                               + euler_vector[2]*euler_vector[2]));
  
  T normEulerVec[3];

  for (i=0; i<3; i++)
    normEulerVec[i] = (T)(euler_vector[i] / normVec);
  

  // Enter the remaining quaternion values

  T sin_theta_2 = (T)sin((double)theta_2);

  for (i=0; i<3; i++) {
    this->_elements[i] = normEulerVec[i] * sin_theta_2;
  }
}

template<class T>

T claraty::Quaternion< T >::get_euler_angle

(

)

Return the Euler angle associated with the quaternion

Definition at line 629 of file quaternion.h.

References claraty::Quaternion< T >::negate().

{
  double l;
  T angle;

  if (this->_elements[3] < 0.0)
    negate();
  l = sqrt((double)(this->_elements[0]*this->_elements[0] +
                 this->_elements[1]*this->_elements[1] + this->_elements[2]*this->_elements[2]));

  angle = (T)atan2( l, (double)this->_elements[3] );

  return((T)((T)2.0 * (l != (T)0.0 ? angle : (T)0.0 )));

}

Here is the call graph for this function:

template<class T>

T claraty::Quaternion< T >::norm

(

)

const

Return the norm of the quaternion

Definition at line 648 of file quaternion.h.

Referenced by claraty::Quaternion< T >::normalize(), claraty::Quaternion< T >::Quaternion(), and claraty::Quaternion< T >::quaternion_to_rotation_matrix().

{
  double local_norm = sqrt(this->_elements[0] * this->_elements[0] +
                           this->_elements[1] * this->_elements[1] +
                           this->_elements[2] * this->_elements[2] +
                           this->_elements[3] * this->_elements[3]);

  return((T)local_norm);
}

template<class T>

void claraty::Quaternion< T >::conjugate

(

)

Take the conjugate of the quaternion

Definition at line 705 of file quaternion.h.

Referenced by claraty::Quaternion< T >::operator *(), claraty::Quaternion< T >::operator/(), claraty::Quaternion< double >::reverse(), claraty::ME_Body::rotate_center_of_mass(), and claraty::ME_Joint::rotate_joint_axes().

{
  for (int i=0; i<3; i++)
     this->_elements[i] = - this->_elements[i];

}

template<class T>

void claraty::Quaternion< T >::negate

(

)

Negate the quaternion

Definition at line 715 of file quaternion.h.

Referenced by claraty::Quaternion< T >::get_euler_angle(), claraty::Quaternion< T >::interpolate(), claraty::Quaternion< T >::operator/(), claraty::Quaternion< T >::rotation_matrix_to_quaternion(), and claraty::Quaternion< T >::standardize().

{
  for (int i=0; i<4; i++)
     this->_elements[i] = - this->_elements[i];
}

template<class T>

Quaternion< T > claraty::Quaternion< T >::interpolate	(	const T &	k,
		Quaternion< T > &	a
	)			const

Return an interpolated quaternion that is k (0<k<1) between this quaternion and the input quaternion

Definition at line 742 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements, claraty::Quaternion< T >::negate(), and claraty::Quaternion< T >::power().

{
  Quaternion temp1(*this), temp2;
  
  temp1.conjugate();
  temp2 = a * temp1;
  
  if (temp2._elements[3] < 0.0)
    temp2.negate();
  temp2.power(k);
  temp1 = temp2 * *this;
  return temp1;
}

Here is the call graph for this function:

template<class T>

void claraty::Quaternion< T >::scale

(

const T &

d

)

Scale the quaternion

Definition at line 696 of file quaternion.h.

Referenced by claraty::Quaternion< T >::normalize().

{
        for (int i = 0; i<4; i++)
                this->_elements[i] = d * this->_elements[i];
}

template<class T>

void claraty::Quaternion< T >::normalize

(

)

Normalize the quaternion

Definition at line 662 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements, claraty::Quaternion< T >::norm(), and claraty::Quaternion< T >::scale().

Referenced by claraty::Quaternion< T >::power().

{
  T d;
  
  d = norm();
  if (d > 0.0)
    {
      scale(1/d);
    }
  else
    {
      this->_elements[0] = 0.0;
      this->_elements[1] = 0.0;
      this->_elements[2] = 0.0;
      this->_elements[3] = 1.0;
    }
}

Here is the call graph for this function:

template<class T>

void claraty::Quaternion< T >::power

(

const T &

p

)

Take the quaternion to the pth power

Definition at line 724 of file quaternion.h.

References claraty::Base_Quaternion< T >::_elements, and claraty::Quaternion< T >::normalize().

Referenced by claraty::Quaternion< T >::interpolate().

{
  normalize();
  double s = sqrt((double)(this->_elements[0]*this->_elements[0] +
          this->_elements[1]*this->_elements[1] + this->_elements[2]*this->_elements[2]));
  if (s!=0.0)
  {
    double t = atan2(s, (double)(this->_elements[3])) * p;
    for (int i=0; i<3; i++)
      this->_elements[i] *= (T)(sin(t) / s);
      this->_elements[3] = (T)cos(t);
  }
}

Here is the call graph for this function:

template<class T>

void claraty::Quaternion< T >::standardize

(

)

Standardize the quaternion

Definition at line 684 of file quaternion.h.

References claraty::Quaternion< T >::negate().

{
  if (this->_elements[3] < 0.0)
    {
      negate();
    }
}

Here is the call graph for this function:

template<class T>

void claraty::Quaternion< T >::set_identity

(

)

[inline]

Definition at line 118 of file quaternion.h.

Referenced by claraty::Quaternion< T >::Quaternion().

{ *this = identity;}

template<class T>

bool claraty::Quaternion< T >::io

(

FDM_Map

map

)

Definition at line 846 of file quaternion.h.

References claraty::FDM_Map::field(), claraty::FDM_Map::is_read(), and claraty::FDM_Map::is_write().

{
  T qi, qj, qk, qs;
  
  if (map.is_write()) {
    qi = this->_elements[0];
    qj = this->_elements[1];
    qk = this->_elements[2];
    qs = this->_elements[3];
  }
  
  bool ok = map.field("qi", qi);
  ok &= map.field("qj", qj);
  ok &= map.field("qk", qk);
  ok &= map.field("qs", qs);
    
  if (map.is_read())
  {
    this->_elements[0] = qi;
    this->_elements[1] = qj;
    this->_elements[2] = qk;
    this->_elements[3] = qs;
  }

  return ok;
}

Here is the call graph for this function:

template<class T>

Quaternion claraty::Quaternion< T >::reverse

(

)

[inline]

Definition at line 121 of file quaternion.h.

Referenced by claraty::Frame_IO::convert_to_internal_format().

    {
      Quaternion<T> temp(*this);
      temp.conjugate();
      return temp;
    };

template<class T>

Vector<T> claraty::Quaternion< T >::get_x_axis

(

)

const [inline]

Definition at line 130 of file quaternion.h.

                               {
    return quaternion_to_rotation_matrix().get_x_axis();
  }

template<class T>

Vector<T> claraty::Quaternion< T >::get_y_axis

(

)

const [inline]

Definition at line 133 of file quaternion.h.

                               {
    return quaternion_to_rotation_matrix().get_y_axis();
  }

template<class T>

Vector<T> claraty::Quaternion< T >::get_z_axis

(

)

const [inline]

Definition at line 136 of file quaternion.h.

                               {
    return quaternion_to_rotation_matrix().get_z_axis();
  }

template<class T>

void claraty::Quaternion< T >::get_rpy_angles	(	T &	roll,
		T &	pitch,
		T &	yaw
	)			const

Converts this quaternion into equivalent roll, pitch, yaw angles

Definition at line 511 of file quaternion.h.

References claraty::RMatrix< T >::get_rpy_angles(), and claraty::Quaternion< T >::quaternion_to_rotation_matrix().

{
  RMatrix<T> a = quaternion_to_rotation_matrix();
  a.get_rpy_angles(roll, pitch, yaw);
}

Here is the call graph for this function:

---

Friends And Related Function Documentation

template<class T>

template<class Y>

std::ostream& operator<<	(	std::ostream &	os,
		const Quaternion< Y > &	q
	)			[friend]

---

Member Data Documentation

template<class T>

const Base_Quaternion< T > claraty::Quaternion< T >::identity [static]

Definition at line 142 of file quaternion.h.

Referenced by claraty::Quaternion< double >::set_identity().

template<class T>

T claraty::Base_Quaternion< T >::_elements[4] [inherited]

Definition at line 59 of file quaternion.h.

Referenced by claraty::Quaternion< T >::euler_parameters_to_quaternion(), claraty::Quaternion< T >::interpolate(), claraty::Quaternion< T >::normalize(), claraty::Quaternion< T >::operator *(), claraty::Quaternion< double >::operator()(), claraty::Quaternion< T >::operator/(), claraty::Quaternion< T >::operator=(), claraty::Quaternion< T >::operator==(), claraty::Quaternion< T >::power(), claraty::Quaternion< T >::Quaternion(), claraty::Quaternion< T >::quaternion_to_theta_triple(), claraty::Quaternion< T >::rotation_matrix_to_quaternion(), and claraty::Quaternion< T >::theta_triple_to_quaternion().

---

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

• quaternion.h

Last modified: June 05 2007 10:19:53

JPL PRIVACY STATEMENT GLOSSARY SITEMAP FEEDBACK CONTACT US

Site Manager: Issa A.D. Nesnas
Site Maintainer: Kelly Breed
Document Clearance #: CL 07-0635