1// This file is part of Eigen, a lightweight C++ template library 2// for linear algebra. 3// 4// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr> 5// 6// This Source Code Form is subject to the terms of the Mozilla 7// Public License v. 2.0. If a copy of the MPL was not distributed 8// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 10#ifndef EIGEN_ROTATION2D_H 11#define EIGEN_ROTATION2D_H 12 13namespace Eigen { 14 15/** \geometry_module \ingroup Geometry_Module 16 * 17 * \class Rotation2D 18 * 19 * \brief Represents a rotation/orientation in a 2 dimensional space. 20 * 21 * \param _Scalar the scalar type, i.e., the type of the coefficients 22 * 23 * This class is equivalent to a single scalar representing a counter clock wise rotation 24 * as a single angle in radian. It provides some additional features such as the automatic 25 * conversion from/to a 2x2 rotation matrix. Moreover this class aims to provide a similar 26 * interface to Quaternion in order to facilitate the writing of generic algorithms 27 * dealing with rotations. 28 * 29 * \sa class Quaternion, class Transform 30 */ 31 32namespace internal { 33 34template<typename _Scalar> struct traits<Rotation2D<_Scalar> > 35{ 36 typedef _Scalar Scalar; 37}; 38} // end namespace internal 39 40template<typename _Scalar> 41class Rotation2D : public RotationBase<Rotation2D<_Scalar>,2> 42{ 43 typedef RotationBase<Rotation2D<_Scalar>,2> Base; 44 45public: 46 47 using Base::operator*; 48 49 enum { Dim = 2 }; 50 /** the scalar type of the coefficients */ 51 typedef _Scalar Scalar; 52 typedef Matrix<Scalar,2,1> Vector2; 53 typedef Matrix<Scalar,2,2> Matrix2; 54 55protected: 56 57 Scalar m_angle; 58 59public: 60 61 /** Construct a 2D counter clock wise rotation from the angle \a a in radian. */ 62 inline Rotation2D(const Scalar& a) : m_angle(a) {} 63 64 /** \returns the rotation angle */ 65 inline Scalar angle() const { return m_angle; } 66 67 /** \returns a read-write reference to the rotation angle */ 68 inline Scalar& angle() { return m_angle; } 69 70 /** \returns the inverse rotation */ 71 inline Rotation2D inverse() const { return -m_angle; } 72 73 /** Concatenates two rotations */ 74 inline Rotation2D operator*(const Rotation2D& other) const 75 { return m_angle + other.m_angle; } 76 77 /** Concatenates two rotations */ 78 inline Rotation2D& operator*=(const Rotation2D& other) 79 { m_angle += other.m_angle; return *this; } 80 81 /** Applies the rotation to a 2D vector */ 82 Vector2 operator* (const Vector2& vec) const 83 { return toRotationMatrix() * vec; } 84 85 template<typename Derived> 86 Rotation2D& fromRotationMatrix(const MatrixBase<Derived>& m); 87 Matrix2 toRotationMatrix(void) const; 88 89 /** \returns the spherical interpolation between \c *this and \a other using 90 * parameter \a t. It is in fact equivalent to a linear interpolation. 91 */ 92 inline Rotation2D slerp(const Scalar& t, const Rotation2D& other) const 93 { return m_angle * (1-t) + other.angle() * t; } 94 95 /** \returns \c *this with scalar type casted to \a NewScalarType 96 * 97 * Note that if \a NewScalarType is equal to the current scalar type of \c *this 98 * then this function smartly returns a const reference to \c *this. 99 */ 100 template<typename NewScalarType> 101 inline typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type cast() const 102 { return typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type(*this); } 103 104 /** Copy constructor with scalar type conversion */ 105 template<typename OtherScalarType> 106 inline explicit Rotation2D(const Rotation2D<OtherScalarType>& other) 107 { 108 m_angle = Scalar(other.angle()); 109 } 110 111 static inline Rotation2D Identity() { return Rotation2D(0); } 112 113 /** \returns \c true if \c *this is approximately equal to \a other, within the precision 114 * determined by \a prec. 115 * 116 * \sa MatrixBase::isApprox() */ 117 bool isApprox(const Rotation2D& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const 118 { return internal::isApprox(m_angle,other.m_angle, prec); } 119}; 120 121/** \ingroup Geometry_Module 122 * single precision 2D rotation type */ 123typedef Rotation2D<float> Rotation2Df; 124/** \ingroup Geometry_Module 125 * double precision 2D rotation type */ 126typedef Rotation2D<double> Rotation2Dd; 127 128/** Set \c *this from a 2x2 rotation matrix \a mat. 129 * In other words, this function extract the rotation angle 130 * from the rotation matrix. 131 */ 132template<typename Scalar> 133template<typename Derived> 134Rotation2D<Scalar>& Rotation2D<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat) 135{ 136 using std::atan2; 137 EIGEN_STATIC_ASSERT(Derived::RowsAtCompileTime==2 && Derived::ColsAtCompileTime==2,YOU_MADE_A_PROGRAMMING_MISTAKE) 138 m_angle = atan2(mat.coeff(1,0), mat.coeff(0,0)); 139 return *this; 140} 141 142/** Constructs and \returns an equivalent 2x2 rotation matrix. 143 */ 144template<typename Scalar> 145typename Rotation2D<Scalar>::Matrix2 146Rotation2D<Scalar>::toRotationMatrix(void) const 147{ 148 using std::sin; 149 using std::cos; 150 Scalar sinA = sin(m_angle); 151 Scalar cosA = cos(m_angle); 152 return (Matrix2() << cosA, -sinA, sinA, cosA).finished(); 153} 154 155} // end namespace Eigen 156 157#endif // EIGEN_ROTATION2D_H 158