// This file is part of Eigen, a lightweight C++ template library // for linear algebra. // // Copyright (C) 2008 Gael Guennebaud // // This Source Code Form is subject to the terms of the Mozilla // Public License v. 2.0. If a copy of the MPL was not distributed // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. // no include guard, we'll include this twice from All.h from Eigen2Support, and it's internal anyway namespace Eigen { /** \geometry_module \ingroup Geometry_Module * * \class Translation * * \brief Represents a translation transformation * * \param _Scalar the scalar type, i.e., the type of the coefficients. * \param _Dim the dimension of the space, can be a compile time value or Dynamic * * \note This class is not aimed to be used to store a translation transformation, * but rather to make easier the constructions and updates of Transform objects. * * \sa class Scaling, class Transform */ template class Translation { public: EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim) /** dimension of the space */ enum { Dim = _Dim }; /** the scalar type of the coefficients */ typedef _Scalar Scalar; /** corresponding vector type */ typedef Matrix VectorType; /** corresponding linear transformation matrix type */ typedef Matrix LinearMatrixType; /** corresponding scaling transformation type */ typedef Scaling ScalingType; /** corresponding affine transformation type */ typedef Transform TransformType; protected: VectorType m_coeffs; public: /** Default constructor without initialization. */ Translation() {} /** */ inline Translation(const Scalar& sx, const Scalar& sy) { ei_assert(Dim==2); m_coeffs.x() = sx; m_coeffs.y() = sy; } /** */ inline Translation(const Scalar& sx, const Scalar& sy, const Scalar& sz) { ei_assert(Dim==3); m_coeffs.x() = sx; m_coeffs.y() = sy; m_coeffs.z() = sz; } /** Constructs and initialize the scaling transformation from a vector of scaling coefficients */ explicit inline Translation(const VectorType& vector) : m_coeffs(vector) {} const VectorType& vector() const { return m_coeffs; } VectorType& vector() { return m_coeffs; } /** Concatenates two translation */ inline Translation operator* (const Translation& other) const { return Translation(m_coeffs + other.m_coeffs); } /** Concatenates a translation and a scaling */ inline TransformType operator* (const ScalingType& other) const; /** Concatenates a translation and a linear transformation */ inline TransformType operator* (const LinearMatrixType& linear) const; template inline TransformType operator*(const RotationBase& r) const { return *this * r.toRotationMatrix(); } /** Concatenates a linear transformation and a translation */ // its a nightmare to define a templated friend function outside its declaration friend inline TransformType operator* (const LinearMatrixType& linear, const Translation& t) { TransformType res; res.matrix().setZero(); res.linear() = linear; res.translation() = linear * t.m_coeffs; res.matrix().row(Dim).setZero(); res(Dim,Dim) = Scalar(1); return res; } /** Concatenates a translation and an affine transformation */ inline TransformType operator* (const TransformType& t) const; /** Applies translation to vector */ inline VectorType operator* (const VectorType& other) const { return m_coeffs + other; } /** \returns the inverse translation (opposite) */ Translation inverse() const { return Translation(-m_coeffs); } Translation& operator=(const Translation& other) { m_coeffs = other.m_coeffs; return *this; } /** \returns \c *this with scalar type casted to \a NewScalarType * * Note that if \a NewScalarType is equal to the current scalar type of \c *this * then this function smartly returns a const reference to \c *this. */ template inline typename internal::cast_return_type >::type cast() const { return typename internal::cast_return_type >::type(*this); } /** Copy constructor with scalar type conversion */ template inline explicit Translation(const Translation& other) { m_coeffs = other.vector().template cast(); } /** \returns \c true if \c *this is approximately equal to \a other, within the precision * determined by \a prec. * * \sa MatrixBase::isApprox() */ bool isApprox(const Translation& other, typename NumTraits::Real prec = precision()) const { return m_coeffs.isApprox(other.m_coeffs, prec); } }; /** \addtogroup Geometry_Module */ //@{ typedef Translation Translation2f; typedef Translation Translation2d; typedef Translation Translation3f; typedef Translation Translation3d; //@} template inline typename Translation::TransformType Translation::operator* (const ScalingType& other) const { TransformType res; res.matrix().setZero(); res.linear().diagonal() = other.coeffs(); res.translation() = m_coeffs; res(Dim,Dim) = Scalar(1); return res; } template inline typename Translation::TransformType Translation::operator* (const LinearMatrixType& linear) const { TransformType res; res.matrix().setZero(); res.linear() = linear; res.translation() = m_coeffs; res.matrix().row(Dim).setZero(); res(Dim,Dim) = Scalar(1); return res; } template inline typename Translation::TransformType Translation::operator* (const TransformType& t) const { TransformType res = t; res.pretranslate(m_coeffs); return res; } } // end namespace Eigen