Rotation.h File Reference

#include "SimTKcommon/SmallMatrix.h"
#include "SimTKcommon/internal/UnitVec.h"
#include "SimTKcommon/internal/Quaternion.h"
#include "SimTKcommon/internal/CoordinateAxis.h"
#include <iosfwd>

Go to the source code of this file.

Classes
class	Rotation_< P >
	The Rotation class is a Mat33 that guarantees that the matrix is a legitimate 3x3 array associated with the relative orientation of two right-handed, orthogonal, unit vector bases. More...
class	InverseRotation_< P >
	----------------------------------------------------------------------------- This InverseRotation class is the inverse of a Rotation See the Rotation class for information. More...
Namespaces
namespace	SimTK
	This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with other symbols.
Typedefs
typedef Rotation_< Real >	Rotation
typedef Rotation_< float >	fRotation
typedef Rotation_< double >	dRotation
typedef InverseRotation_< Real >	InverseRotation
typedef InverseRotation_< float >	fInverseRotation
typedef InverseRotation_< double >	dInverseRotation
Enumerations
enum	BodyOrSpaceType { BodyRotationSequence = 0, SpaceRotationSequence = 1 }
Functions
template<class P >
std::ostream &	operator<< (std::ostream &, const Rotation_< P > &)
	Write a Rotation matrix to an output stream by writing out its underlying Mat33.
template<class P >
std::ostream &	operator<< (std::ostream &, const InverseRotation_< P > &)
	Write an InverseRotation matrix to an output stream by writing out its underlying Mat33.
template<class P , int S>
UnitVec< P, 1 >	operator* (const Rotation_< P > &R, const UnitVec< P, S > &v)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P , int S>
UnitRow< P, 1 >	operator* (const UnitRow< P, S > &r, const Rotation_< P > &R)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P , int S>
UnitVec< P, 1 >	operator* (const InverseRotation_< P > &R, const UnitVec< P, S > &v)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P , int S>
UnitRow< P, 1 >	operator* (const UnitRow< P, S > &r, const InverseRotation_< P > &R)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P >
Rotation_< P >	operator* (const Rotation_< P > &R1, const Rotation_< P > &R2)
	Composition of Rotation matrices via operator*.
template<class P >
Rotation_< P >	operator* (const Rotation_< P > &R1, const InverseRotation_< P > &R2)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P >
Rotation_< P >	operator* (const InverseRotation_< P > &R1, const Rotation_< P > &R2)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P >
Rotation_< P >	operator* (const InverseRotation_< P > &R1, const InverseRotation_< P > &R2)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P >
Rotation_< P >	operator/ (const Rotation_< P > &R1, const Rotation_< P > &R2)
	Composition of a Rotation matrix and the inverse of another Rotation via operator/, that is R1/R2 == R1*(~R2).
template<class P >
Rotation_< P >	operator/ (const Rotation_< P > &R1, const InverseRotation &R2)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P >
Rotation_< P >	operator/ (const InverseRotation_< P > &R1, const Rotation_< P > &R2)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.
template<class P >
Rotation_< P >	operator/ (const InverseRotation_< P > &R1, const InverseRotation_< P > &R2)
	Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization.