ACG::QuaternionT< Scalar > Class Template Reference

#include <ACG/Math/QuaternionT.hh>

Inheritance diagram for ACG::QuaternionT< Scalar >:

Public Types
typedef VectorT< Scalar, 4 >	Base
typedef QuaternionT< Scalar >	Quaternion
typedef VectorT< Scalar, 3 >	Vec3
typedef VectorT< Scalar, 4 >	Vec4
typedef Matrix4x4T< Scalar >	Matrix
Public Types inherited from OpenMesh::VectorT< Scalar, DIM >
typedef Scalar	value_type
	the type of the scalar used in this template
typedef VectorT< Scalar, DIM >	vector_type
	type of this vector
using	iterator = typename container::iterator
using	const_iterator = typename container::const_iterator
using	reverse_iterator = typename container::reverse_iterator
using	const_reverse_iterator = typename container::const_reverse_iterator

Public Member Functions
	QuaternionT (Scalar _w=1.0, Scalar _x=0.0, Scalar _y=0.0, Scalar _z=0.0)
	construct from 4 Scalars (default)
	QuaternionT (const Vec3 &_p)
	construct from 3D point (pure imaginary quaternion)
	QuaternionT (const Vec4 &_p)
	construct from 4D vector
	QuaternionT (Vec3 _axis, Scalar _angle)
	construct from rotation axis and angle (in radians)
template<class MatrixT >
	QuaternionT (const MatrixT &_rot)
	construct from rotation matrix (only valid for rotation matrices!)
void	identity ()
	identity rotation
Quaternion	conjugate () const
	conjugate quaternion
Quaternion	invert () const
	invert quaternion
Quaternion	operator* (const Quaternion &_q) const
	quaternion * quaternion
Quaternion &	operator*= (const Quaternion &_q)
	quaternion *= quaternion
template<class Vec3T >
Vec3T	rotate (const Vec3T &_v) const
	rotate vector
void	axis_angle (Vec3 &_axis, Scalar &_angle) const
	get rotation axis and angle (only valid for unit quaternions!)
Matrix	rotation_matrix () const
	cast to rotation matrix
Matrix	right_mult_matrix () const
	get matrix for mult from right (p*q = Qp)
Matrix	left_mult_matrix () const
	get matrix for mult from left (q*p = Qp)
template<class MatrixT >
void	init_from_matrix (const MatrixT &_rot)
	get quaternion from rotation matrix
Quaternion	exponential () const
	quaternion exponential (for unit quaternions)
Quaternion	logarithm () const
	quaternion logarithm (for unit quaternions)
void	print_info ()
Public Member Functions inherited from OpenMesh::VectorT< Scalar, DIM >
template<typename... T, typename = typename std::enable_if<sizeof...(T) == DIM>::type, typename = typename std::enable_if< are_convertible_to<Scalar, T...>::value>::type>
constexpr	VectorT (T...vs)
constexpr	VectorT ()
	default constructor creates uninitialized values.
	VectorT (const Scalar &v)
	VectorT (const VectorT &rhs)=default
	VectorT (VectorT &&rhs)=default
VectorT &	operator= (const VectorT &rhs)=default
VectorT &	operator= (VectorT &&rhs)=default
template<typename S = Scalar, int D = DIM>
auto	homogenized () const -> typename std::enable_if< D==4, VectorT< decltype(std::declval< S >()/std::declval< S >()), DIM >>::type
template<typename Iterator , typename = decltype( *std::declval<Iterator&>(), void(), ++std::declval<Iterator&>(), void())>
	VectorT (Iterator it)
	construct from a value array or any other iterator
template<typename otherScalarType , typename = typename std::enable_if< std::is_convertible<otherScalarType, Scalar>::value>>
	VectorT (const VectorT< otherScalarType, DIM > &_rhs)
	copy & cast constructor (explicit)
template<typename OtherScalar , typename = typename std::enable_if< std::is_convertible<OtherScalar, Scalar>::value>>
vector_type &	operator= (const VectorT< OtherScalar, DIM > &_rhs)
	cast from vector with a different scalar type
Scalar *	data ()
	access to Scalar array
const Scalar *	data () const
	access to const Scalar array
Scalar &	operator[] (size_t _i)
	get i'th element read-write
const Scalar &	operator[] (size_t _i) const
	get i'th element read-only
bool	operator== (const vector_type &_rhs) const
	component-wise comparison
bool	operator!= (const vector_type &_rhs) const
	component-wise comparison
template<typename OtherScalar >
auto	operator*= (const OtherScalar &_s) -> typename std::enable_if< std::is_convertible< decltype(this->values_[0]*_s), Scalar >::value, VectorT< Scalar, DIM > & >::type
	component-wise self-multiplication with scalar
template<typename OtherScalar >
auto	operator/= (const OtherScalar &_s) -> typename std::enable_if< std::is_convertible< decltype(this->values_[0]/_s), Scalar >::value, VectorT< Scalar, DIM > & >::type
	component-wise self-division by scalar
template<typename OtherScalar >
std::enable_if< std::is_convertible< decltype(std::declval< Scalar >)*std::declval< OtherScalar >)), Scalar >::value, VectorT< Scalar, DIM > >::type	operator* (const OtherScalar &_s) const
	component-wise multiplication with scalar
template<typename OtherScalar >
std::enable_if< std::is_convertible< decltype(std::declval< Scalar >)/std::declval< OtherScalar >)), Scalar >::value, VectorT< Scalar, DIM > >::type	operator/ (const OtherScalar &_s) const
	component-wise division by with scalar
template<typename OtherScalar >
auto	operator*= (const VectorT< OtherScalar, DIM > &_rhs) -> typename std::enable_if< sizeof(decltype(this->values_[0]**_rhs.data())) >=0
	component-wise self-multiplication
template<typename OtherScalar >
auto	operator/= (const VectorT< OtherScalar, DIM > &_rhs) -> typename std::enable_if< sizeof(decltype(this->values_[0]/*_rhs.data())) >=0
	component-wise self-division
template<typename OtherScalar >
auto	operator-= (const VectorT< OtherScalar, DIM > &_rhs) -> typename std::enable_if< sizeof(decltype(this->values_[0]-*_rhs.data())) >=0
	vector difference from this
template<typename OtherScalar >
auto	operator+= (const VectorT< OtherScalar, DIM > &_rhs) -> typename std::enable_if< sizeof(decltype(this->values_[0]+*_rhs.data())) >=0
	vector self-addition
template<typename OtherScalar >
auto	operator* (const VectorT< OtherScalar, DIM > &_rhs) const -> typename std::enable_if< sizeof(decltype(this->values_[0]**_rhs.data())) >=0
	component-wise vector multiplication
template<typename OtherScalar >
auto	operator/ (const VectorT< OtherScalar, DIM > &_rhs) const -> typename std::enable_if< sizeof(decltype(this->values_[0]/*_rhs.data())) >=0
	component-wise vector division
template<typename OtherScalar >
auto	operator+ (const VectorT< OtherScalar, DIM > &_rhs) const -> typename std::enable_if< sizeof(decltype(this->values_[0]+*_rhs.data())) >=0
	component-wise vector addition
template<typename OtherScalar >
auto	operator- (const VectorT< OtherScalar, DIM > &_rhs) const -> typename std::enable_if< sizeof(decltype(this->values_[0]-*_rhs.data())) >=0
	component-wise vector difference
vector_type	operator- (void) const
	unary minus
template<typename OtherScalar >
auto	operator% (const VectorT< OtherScalar, DIM > &_rhs) const -> typename std::enable_if< DIM==3, VectorT< decltype((*this)[0]*_rhs[0]-(*this)[0]*_rhs[0]), DIM >>::type
template<typename OtherScalar >
auto	operator| (const VectorT< OtherScalar, DIM > &_rhs) const -> decltype(*this->data()**_rhs.data())
template<typename Functor >
vector_type	apply (const Functor &_func) const
	component-wise apply function object with Scalar operator()(Scalar).
vector_type &	vectorize (const Scalar &_s)
	store the same value in each component (e.g. to clear all entries)
bool	operator< (const vector_type &_rhs) const
	lexicographical comparison
void	swap (VectorT &_other) noexcept(noexcept(std::swap(values_, _other.values_)))
	swap with another vector
template<typename S = Scalar>
decltype(std::declval< S >()*std::declval< S >())	sqrnorm () const
	compute squared euclidean norm
template<typename S = Scalar>
auto	norm () const -> decltype(std::sqrt(std::declval< VectorT< S, DIM >>().sqrnorm()))
	compute euclidean norm
template<typename S = Scalar>
auto	length () const -> decltype(std::declval< VectorT< S, DIM >>().norm())
	compute squared euclidean norm
template<typename S = Scalar>
auto	normalize () -> decltype(*this/=std::declval< VectorT< S, DIM >>().norm())
template<typename S = Scalar>
auto	normalized () const -> decltype(*this/std::declval< VectorT< S, DIM >>().norm())
template<typename S = Scalar>
vector_type &::type	normalize_cond ()
	compute squared euclidean norm
Scalar	l1_norm () const
	compute L1 (Manhattan) norm
Scalar	l8_norm () const
	compute l8_norm
Scalar	max () const
	return the maximal component
Scalar	max_abs () const
	return the maximal absolute component
Scalar	min () const
	return the minimal component
Scalar	min_abs () const
	return the minimal absolute component
Scalar	mean () const
	return arithmetic mean
Scalar	mean_abs () const
	return absolute arithmetic mean
vector_type &	minimize (const vector_type &_rhs)
	minimize values: same as *this = min(*this, _rhs), but faster
bool	minimized (const vector_type &_rhs)
	minimize values and signalize coordinate minimization
vector_type &	maximize (const vector_type &_rhs)
	maximize values: same as *this = max(*this, _rhs), but faster
bool	maximized (const vector_type &_rhs)
	maximize values and signalize coordinate maximization
vector_type	min (const vector_type &_rhs) const
	component-wise min
vector_type	max (const vector_type &_rhs) const
	component-wise max
iterator	begin () noexcept
const_iterator	begin () const noexcept
const_iterator	cbegin () const noexcept
iterator	end () noexcept
const_iterator	end () const noexcept
const_iterator	cend () const noexcept
reverse_iterator	rbegin () noexcept
const_reverse_iterator	rbegin () const noexcept
const_reverse_iterator	crbegin () const noexcept
reverse_iterator	rend () noexcept
const_reverse_iterator	rend () const noexcept
const_reverse_iterator	crend () const noexcept

Additional Inherited Members
Static Public Member Functions inherited from OpenMesh::VectorT< Scalar, DIM >
static constexpr int	dim ()
	returns dimension of the vector (deprecated)
static constexpr size_t	size ()
	returns dimension of the vector
static vector_type	vectorized (const Scalar &_s)
	store the same value in each component
Static Public Attributes inherited from OpenMesh::VectorT< Scalar, DIM >
static constexpr const size_t	size_ = DIM
Related Functions inherited from OpenMesh::VectorT< Scalar, DIM >
template<typename Scalar1 , typename Scalar2 , int N>
VectorT< Scalar1, N >	operator* (Scalar2 _s, const VectorT< Scalar1, N > &_v)
template<typename Scalar , int N>
Scalar	dot (const VectorT< Scalar, N > &_v1, const VectorT< Scalar, N > &_v2)
template<typename Scalar , int N>
VectorT< Scalar, N >	cross (const VectorT< Scalar, N > &_v1, const VectorT< Scalar, N > &_v2)
template<typename Scalar , int DIM>
Scalar	dot (const VectorT< Scalar, DIM > &_v1, const VectorT< Scalar, DIM > &_v2)
template<typename LScalar , typename RScalar , int DIM>
auto	cross (const VectorT< LScalar, DIM > &_v1, const VectorT< RScalar, DIM > &_v2) -> decltype(_v1%_v2)
template<typename Scalar , int DIM>
void	swap (VectorT< Scalar, DIM > &_v1, VectorT< Scalar, DIM > &_v2) noexcept(noexcept(_v1.swap(_v2)))
template<typename Scalar1 , typename Scalar2 , int N>
VectorT< Scalar1, N >	operator* (Scalar2 _s, const VectorT< Scalar1, N > &_v)
template<typename Scalar , int N>
Scalar	dot (const VectorT< Scalar, N > &_v1, const VectorT< Scalar, N > &_v2)
template<typename Scalar , int N>
VectorT< Scalar, N >	cross (const VectorT< Scalar, N > &_v1, const VectorT< Scalar, N > &_v2)

Detailed Description

template<class Scalar>
class ACG::QuaternionT< Scalar >

Quaternion class for representing rotations.

Definition at line 81 of file QuaternionT.hh.

---

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

• ACG/Math/QuaternionT.hh