Scaling.h
Go to the documentation of this file.
00001 // This file is part of Eigen, a lightweight C++ template library
00002 // for linear algebra.
00003 //
00004 // Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
00005 //
00006 // Eigen is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 3 of the License, or (at your option) any later version.
00010 //
00011 // Alternatively, you can redistribute it and/or
00012 // modify it under the terms of the GNU General Public License as
00013 // published by the Free Software Foundation; either version 2 of
00014 // the License, or (at your option) any later version.
00015 //
00016 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
00017 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00018 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
00019 // GNU General Public License for more details.
00020 //
00021 // You should have received a copy of the GNU Lesser General Public
00022 // License and a copy of the GNU General Public License along with
00023 // Eigen. If not, see <http://www.gnu.org/licenses/>.
00024 
00025 #ifndef EIGEN_SCALING_H
00026 #define EIGEN_SCALING_H
00027 
00028 namespace Eigen { 
00029 
00047 template<typename _Scalar>
00048 class UniformScaling
00049 {
00050 public:
00052   typedef _Scalar Scalar;
00053 
00054 protected:
00055 
00056   Scalar m_factor;
00057 
00058 public:
00059 
00061   UniformScaling() {}
00063   explicit inline UniformScaling(const Scalar& s) : m_factor(s) {}
00064 
00065   inline const Scalar& factor() const { return m_factor; }
00066   inline Scalar& factor() { return m_factor; }
00067 
00069   inline UniformScaling operator* (const UniformScaling& other) const
00070   { return UniformScaling(m_factor * other.factor()); }
00071 
00073   template<int Dim>
00074   inline Transform<Scalar,Dim,Affine> operator* (const Translation<Scalar,Dim>& t) const;
00075 
00077   template<int Dim, int Mode, int Options>
00078   inline Transform<Scalar,Dim,Mode> operator* (const Transform<Scalar,Dim, Mode, Options>& t) const;
00079 
00081   // TODO returns an expression
00082   template<typename Derived>
00083   inline typename internal::plain_matrix_type<Derived>::type operator* (const MatrixBase<Derived>& other) const
00084   { return other * m_factor; }
00085 
00086   template<typename Derived,int Dim>
00087   inline Matrix<Scalar,Dim,Dim> operator*(const RotationBase<Derived,Dim>& r) const
00088   { return r.toRotationMatrix() * m_factor; }
00089 
00091   inline UniformScaling inverse() const
00092   { return UniformScaling(Scalar(1)/m_factor); }
00093 
00099   template<typename NewScalarType>
00100   inline UniformScaling<NewScalarType> cast() const
00101   { return UniformScaling<NewScalarType>(NewScalarType(m_factor)); }
00102 
00104   template<typename OtherScalarType>
00105   inline explicit UniformScaling(const UniformScaling<OtherScalarType>& other)
00106   { m_factor = Scalar(other.factor()); }
00107 
00112   bool isApprox(const UniformScaling& other, typename NumTraits<Scalar>::Real prec = NumTraits<Scalar>::dummy_precision()) const
00113   { return internal::isApprox(m_factor, other.factor(), prec); }
00114 
00115 };
00116 
00118 // NOTE this operator is defiend in MatrixBase and not as a friend function
00119 // of UniformScaling to fix an internal crash of Intel's ICC
00120 template<typename Derived> typename MatrixBase<Derived>::ScalarMultipleReturnType
00121 MatrixBase<Derived>::operator*(const UniformScaling<Scalar>& s) const
00122 { return derived() * s.factor(); }
00123 
00125 static inline UniformScaling<float> Scaling(float s) { return UniformScaling<float>(s); }
00127 static inline UniformScaling<double> Scaling(double s) { return UniformScaling<double>(s); }
00129 template<typename RealScalar>
00130 static inline UniformScaling<std::complex<RealScalar> > Scaling(const std::complex<RealScalar>& s)
00131 { return UniformScaling<std::complex<RealScalar> >(s); }
00132 
00134 template<typename Scalar>
00135 static inline DiagonalMatrix<Scalar,2> Scaling(Scalar sx, Scalar sy)
00136 { return DiagonalMatrix<Scalar,2>(sx, sy); }
00138 template<typename Scalar>
00139 static inline DiagonalMatrix<Scalar,3> Scaling(Scalar sx, Scalar sy, Scalar sz)
00140 { return DiagonalMatrix<Scalar,3>(sx, sy, sz); }
00141 
00145 template<typename Derived>
00146 static inline const DiagonalWrapper<const Derived> Scaling(const MatrixBase<Derived>& coeffs)
00147 { return coeffs.asDiagonal(); }
00148 
00152 typedef DiagonalMatrix<float, 2> AlignedScaling2f;
00154 typedef DiagonalMatrix<double,2> AlignedScaling2d;
00156 typedef DiagonalMatrix<float, 3> AlignedScaling3f;
00158 typedef DiagonalMatrix<double,3> AlignedScaling3d;
00160 
00161 template<typename Scalar>
00162 template<int Dim>
00163 inline Transform<Scalar,Dim,Affine>
00164 UniformScaling<Scalar>::operator* (const Translation<Scalar,Dim>& t) const
00165 {
00166   Transform<Scalar,Dim,Affine> res;
00167   res.matrix().setZero();
00168   res.linear().diagonal().fill(factor());
00169   res.translation() = factor() * t.vector();
00170   res(Dim,Dim) = Scalar(1);
00171   return res;
00172 }
00173 
00174 template<typename Scalar>
00175 template<int Dim,int Mode,int Options>
00176 inline Transform<Scalar,Dim,Mode>
00177 UniformScaling<Scalar>::operator* (const Transform<Scalar,Dim, Mode, Options>& t) const
00178 {
00179   Transform<Scalar,Dim,Mode> res = t;
00180   res.prescale(factor());
00181   return res;
00182 }
00183 
00184 } // end namespace Eigen
00185 
00186 #endif // EIGEN_SCALING_H