ACG::QuaternionT< Scalar > Class Template Reference
#include <OpenFlipper/libs_required/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 ... Ts, typename = typename std::enable_if<sizeof...(Ts)+1 == DIM>::type, typename = typename std::enable_if< are_convertible_to<Scalar, T, Ts...>::value>::type> | |
| constexpr | VectorT (T v, Ts... 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 | |
| VectorT (container &&_array) | |
| construct from an array | |
| 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 | cross (const VectorT< OtherScalar, DIM > &_rhs) const -> decltype(*this % _rhs) |
| template<typename OtherScalar > | |
| auto | operator| (const VectorT< OtherScalar, DIM > &_rhs) const -> decltype(*this->data() **_rhs.data()) |
| template<typename OtherScalar > | |
| auto | dot (const VectorT< OtherScalar, DIM > &_rhs) const -> decltype(*this|_rhs) |
| 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<> | |
| VectorT< float, 3 > | operator% (const VectorT< float, 3 > &_rhs) const |
| cross product for Vec3f | |
| template<> | |
| VectorT< double, 3 > | operator% (const VectorT< double, 3 > &_rhs) const |
| cross product for Vec3d | |
| 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 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 Scalar , int DIM> | |
| Scalar | norm (const VectorT< Scalar, DIM > &_v) |
| template<typename Scalar , int DIM> | |
| Scalar | sqrnorm (const VectorT< Scalar, DIM > &_v) |
| template<typename Scalar , int DIM, typename OtherScalar > | |
| VectorT< Scalar, DIM > & | vectorize (VectorT< Scalar, DIM > &_v, OtherScalar const &_val) |
| template<typename Scalar , int DIM> | |
| VectorT< Scalar, DIM > & | normalize (VectorT< Scalar, DIM > &_v) |
| template<typename Scalar , int DIM> | |
| VectorT< Scalar, DIM > & | maximize (VectorT< Scalar, DIM > &_v1, VectorT< Scalar, DIM > &_v2) |
| template<typename Scalar , int DIM> | |
| VectorT< Scalar, DIM > & | minimize (VectorT< Scalar, DIM > &_v1, VectorT< Scalar, DIM > &_v2) |
| template<typename Scalar , int DIM> | |
| VectorT< Scalar, DIM > | max (const VectorT< Scalar, DIM > &_v1, const VectorT< Scalar, DIM > &_v2) |
| template<typename Scalar , int DIM> | |
| VectorT< Scalar, DIM > | min (const VectorT< Scalar, DIM > &_v1, const VectorT< Scalar, DIM > &_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) |
| template<typename Scalar , int DIM> | |
| Scalar | norm (const VectorT< Scalar, DIM > &_v) |
| template<typename Scalar , int DIM> | |
| Scalar | sqrnorm (const VectorT< Scalar, DIM > &_v) |
| template<typename Scalar , int DIM, typename OtherScalar > | |
| VectorT< Scalar, DIM > & | vectorize (VectorT< Scalar, DIM > &_v, OtherScalar const &_val) |
| template<typename Scalar , int DIM> | |
| VectorT< Scalar, DIM > & | normalize (VectorT< Scalar, DIM > &_v) |
| template<typename Scalar , int DIM> | |
| VectorT< Scalar, DIM > & | maximize (VectorT< Scalar, DIM > &_v1, VectorT< Scalar, DIM > &_v2) |
| template<typename Scalar , int DIM> | |
| VectorT< Scalar, DIM > & | minimize (VectorT< Scalar, DIM > &_v1, VectorT< Scalar, DIM > &_v2) |
| template<typename Scalar , int DIM> | |
| VectorT< Scalar, DIM > | max (VectorT< Scalar, DIM > &_v1, VectorT< Scalar, DIM > &_v2) |
| template<typename Scalar , int DIM> | |
| VectorT< Scalar, DIM > | min (VectorT< Scalar, DIM > &_v1, VectorT< Scalar, DIM > &_v2) |
Detailed Description
template<class Scalar>
class ACG::QuaternionT< Scalar >
Quaternion class for representing rotations.
Definition at line 75 of file QuaternionT.hh.
The documentation for this class was generated from the following file:
- OpenFlipper/libs_required/ACG/Math/QuaternionT.hh
