• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
13 namespace 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   * \tparam _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 
32 namespace internal {
33 
34 template<typename _Scalar> struct traits<Rotation2D<_Scalar> >
35 {
36   typedef _Scalar Scalar;
37 };
38 } // end namespace internal
39 
40 template<typename _Scalar>
41 class Rotation2D : public RotationBase<Rotation2D<_Scalar>,2>
42 {
43   typedef RotationBase<Rotation2D<_Scalar>,2> Base;
44 
45 public:
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 
55 protected:
56 
57   Scalar m_angle;
58 
59 public:
60 
61   /** Construct a 2D counter clock wise rotation from the angle \a a in radian. */
62   EIGEN_DEVICE_FUNC explicit inline Rotation2D(const Scalar& a) : m_angle(a) {}
63 
64   /** Default constructor wihtout initialization. The represented rotation is undefined. */
65   EIGEN_DEVICE_FUNC Rotation2D() {}
66 
67   /** Construct a 2D rotation from a 2x2 rotation matrix \a mat.
68     *
69     * \sa fromRotationMatrix()
70     */
71   template<typename Derived>
72   EIGEN_DEVICE_FUNC explicit Rotation2D(const MatrixBase<Derived>& m)
73   {
74     fromRotationMatrix(m.derived());
75   }
76 
77   /** \returns the rotation angle */
78   EIGEN_DEVICE_FUNC inline Scalar angle() const { return m_angle; }
79 
80   /** \returns a read-write reference to the rotation angle */
81   EIGEN_DEVICE_FUNC inline Scalar& angle() { return m_angle; }
82 
83   /** \returns the rotation angle in [0,2pi] */
84   EIGEN_DEVICE_FUNC inline Scalar smallestPositiveAngle() const {
85     Scalar tmp = numext::fmod(m_angle,Scalar(2*EIGEN_PI));
86     return tmp<Scalar(0) ? tmp + Scalar(2*EIGEN_PI) : tmp;
87   }
88 
89   /** \returns the rotation angle in [-pi,pi] */
90   EIGEN_DEVICE_FUNC inline Scalar smallestAngle() const {
91     Scalar tmp = numext::fmod(m_angle,Scalar(2*EIGEN_PI));
92     if(tmp>Scalar(EIGEN_PI))       tmp -= Scalar(2*EIGEN_PI);
93     else if(tmp<-Scalar(EIGEN_PI)) tmp += Scalar(2*EIGEN_PI);
94     return tmp;
95   }
96 
97   /** \returns the inverse rotation */
98   EIGEN_DEVICE_FUNC inline Rotation2D inverse() const { return Rotation2D(-m_angle); }
99 
100   /** Concatenates two rotations */
101   EIGEN_DEVICE_FUNC inline Rotation2D operator*(const Rotation2D& other) const
102   { return Rotation2D(m_angle + other.m_angle); }
103 
104   /** Concatenates two rotations */
105   EIGEN_DEVICE_FUNC inline Rotation2D& operator*=(const Rotation2D& other)
106   { m_angle += other.m_angle; return *this; }
107 
108   /** Applies the rotation to a 2D vector */
109   EIGEN_DEVICE_FUNC Vector2 operator* (const Vector2& vec) const
110   { return toRotationMatrix() * vec; }
111 
112   template<typename Derived>
113   EIGEN_DEVICE_FUNC Rotation2D& fromRotationMatrix(const MatrixBase<Derived>& m);
114   EIGEN_DEVICE_FUNC Matrix2 toRotationMatrix() const;
115 
116   /** Set \c *this from a 2x2 rotation matrix \a mat.
117     * In other words, this function extract the rotation angle from the rotation matrix.
118     *
119     * This method is an alias for fromRotationMatrix()
120     *
121     * \sa fromRotationMatrix()
122     */
123   template<typename Derived>
124   EIGEN_DEVICE_FUNC Rotation2D& operator=(const  MatrixBase<Derived>& m)
125   { return fromRotationMatrix(m.derived()); }
126 
127   /** \returns the spherical interpolation between \c *this and \a other using
128     * parameter \a t. It is in fact equivalent to a linear interpolation.
129     */
130   EIGEN_DEVICE_FUNC inline Rotation2D slerp(const Scalar& t, const Rotation2D& other) const
131   {
132     Scalar dist = Rotation2D(other.m_angle-m_angle).smallestAngle();
133     return Rotation2D(m_angle + dist*t);
134   }
135 
136   /** \returns \c *this with scalar type casted to \a NewScalarType
137     *
138     * Note that if \a NewScalarType is equal to the current scalar type of \c *this
139     * then this function smartly returns a const reference to \c *this.
140     */
141   template<typename NewScalarType>
142   EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type cast() const
143   { return typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type(*this); }
144 
145   /** Copy constructor with scalar type conversion */
146   template<typename OtherScalarType>
147   EIGEN_DEVICE_FUNC inline explicit Rotation2D(const Rotation2D<OtherScalarType>& other)
148   {
149     m_angle = Scalar(other.angle());
150   }
151 
152   EIGEN_DEVICE_FUNC static inline Rotation2D Identity() { return Rotation2D(0); }
153 
154   /** \returns \c true if \c *this is approximately equal to \a other, within the precision
155     * determined by \a prec.
156     *
157     * \sa MatrixBase::isApprox() */
158   EIGEN_DEVICE_FUNC bool isApprox(const Rotation2D& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
159   { return internal::isApprox(m_angle,other.m_angle, prec); }
160 
161 };
162 
163 /** \ingroup Geometry_Module
164   * single precision 2D rotation type */
165 typedef Rotation2D<float> Rotation2Df;
166 /** \ingroup Geometry_Module
167   * double precision 2D rotation type */
168 typedef Rotation2D<double> Rotation2Dd;
169 
170 /** Set \c *this from a 2x2 rotation matrix \a mat.
171   * In other words, this function extract the rotation angle
172   * from the rotation matrix.
173   */
174 template<typename Scalar>
175 template<typename Derived>
176 EIGEN_DEVICE_FUNC Rotation2D<Scalar>& Rotation2D<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat)
177 {
178   EIGEN_USING_STD_MATH(atan2)
179   EIGEN_STATIC_ASSERT(Derived::RowsAtCompileTime==2 && Derived::ColsAtCompileTime==2,YOU_MADE_A_PROGRAMMING_MISTAKE)
180   m_angle = atan2(mat.coeff(1,0), mat.coeff(0,0));
181   return *this;
182 }
183 
184 /** Constructs and \returns an equivalent 2x2 rotation matrix.
185   */
186 template<typename Scalar>
187 typename Rotation2D<Scalar>::Matrix2
188 EIGEN_DEVICE_FUNC Rotation2D<Scalar>::toRotationMatrix(void) const
189 {
190   EIGEN_USING_STD_MATH(sin)
191   EIGEN_USING_STD_MATH(cos)
192   Scalar sinA = sin(m_angle);
193   Scalar cosA = cos(m_angle);
194   return (Matrix2() << cosA, -sinA, sinA, cosA).finished();
195 }
196 
197 } // end namespace Eigen
198 
199 #endif // EIGEN_ROTATION2D_H
200