Eigen  3.3.3
Scaling.h
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 // This Source Code Form is subject to the terms of the Mozilla
00007 // Public License v. 2.0. If a copy of the MPL was not distributed
00008 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
00009 
00010 #ifndef EIGEN_SCALING_H
00011 #define EIGEN_SCALING_H
00012 
00013 namespace Eigen { 
00014 
00032 template<typename _Scalar>
00033 class UniformScaling
00034 {
00035 public:
00037   typedef _Scalar Scalar;
00038 
00039 protected:
00040 
00041   Scalar m_factor;
00042 
00043 public:
00044 
00046   UniformScaling() {}
00048   explicit inline UniformScaling(const Scalar& s) : m_factor(s) {}
00049 
00050   inline const Scalar& factor() const { return m_factor; }
00051   inline Scalar& factor() { return m_factor; }
00052 
00054   inline UniformScaling operator* (const UniformScaling& other) const
00055   { return UniformScaling(m_factor * other.factor()); }
00056 
00058   template<int Dim>
00059   inline Transform<Scalar,Dim,Affine> operator* (const Translation<Scalar,Dim>& t) const;
00060 
00062   template<int Dim, int Mode, int Options>
00063   inline Transform<Scalar,Dim,(int(Mode)==int(Isometry)?Affine:Mode)> operator* (const Transform<Scalar,Dim, Mode, Options>& t) const
00064   {
00065     Transform<Scalar,Dim,(int(Mode)==int(Isometry)?Affine:Mode)> res = t;
00066     res.prescale(factor());
00067     return res;
00068   }
00069 
00071   // TODO returns an expression
00072   template<typename Derived>
00073   inline typename internal::plain_matrix_type<Derived>::type operator* (const MatrixBase<Derived>& other) const
00074   { return other * m_factor; }
00075 
00076   template<typename Derived,int Dim>
00077   inline Matrix<Scalar,Dim,Dim> operator*(const RotationBase<Derived,Dim>& r) const
00078   { return r.toRotationMatrix() * m_factor; }
00079 
00081   inline UniformScaling inverse() const
00082   { return UniformScaling(Scalar(1)/m_factor); }
00083 
00089   template<typename NewScalarType>
00090   inline UniformScaling<NewScalarType> cast() const
00091   { return UniformScaling<NewScalarType>(NewScalarType(m_factor)); }
00092 
00094   template<typename OtherScalarType>
00095   inline explicit UniformScaling(const UniformScaling<OtherScalarType>& other)
00096   { m_factor = Scalar(other.factor()); }
00097 
00102   bool isApprox(const UniformScaling& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
00103   { return internal::isApprox(m_factor, other.factor(), prec); }
00104 
00105 };
00106 
00109 
00113 // NOTE this operator is defiend in MatrixBase and not as a friend function
00114 // of UniformScaling to fix an internal crash of Intel's ICC
00115 template<typename Derived,typename Scalar>
00116 EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,Scalar,product)
00117 operator*(const MatrixBase<Derived>& matrix, const UniformScaling<Scalar>& s)
00118 { return matrix.derived() * s.factor(); }
00119 
00121 inline UniformScaling<float> Scaling(float s) { return UniformScaling<float>(s); }
00123 inline UniformScaling<double> Scaling(double s) { return UniformScaling<double>(s); }
00125 template<typename RealScalar>
00126 inline UniformScaling<std::complex<RealScalar> > Scaling(const std::complex<RealScalar>& s)
00127 { return UniformScaling<std::complex<RealScalar> >(s); }
00128 
00130 template<typename Scalar>
00131 inline DiagonalMatrix<Scalar,2> Scaling(const Scalar& sx, const Scalar& sy)
00132 { return DiagonalMatrix<Scalar,2>(sx, sy); }
00134 template<typename Scalar>
00135 inline DiagonalMatrix<Scalar,3> Scaling(const Scalar& sx, const Scalar& sy, const Scalar& sz)
00136 { return DiagonalMatrix<Scalar,3>(sx, sy, sz); }
00137 
00141 template<typename Derived>
00142 inline const DiagonalWrapper<const Derived> Scaling(const MatrixBase<Derived>& coeffs)
00143 { return coeffs.asDiagonal(); }
00144 
00146 typedef DiagonalMatrix<float, 2> AlignedScaling2f;
00148 typedef DiagonalMatrix<double,2> AlignedScaling2d;
00150 typedef DiagonalMatrix<float, 3> AlignedScaling3f;
00152 typedef DiagonalMatrix<double,3> AlignedScaling3d;
00154 
00155 template<typename Scalar>
00156 template<int Dim>
00157 inline Transform<Scalar,Dim,Affine>
00158 UniformScaling<Scalar>::operator* (const Translation<Scalar,Dim>& t) const
00159 {
00160   Transform<Scalar,Dim,Affine> res;
00161   res.matrix().setZero();
00162   res.linear().diagonal().fill(factor());
00163   res.translation() = factor() * t.vector();
00164   res(Dim,Dim) = Scalar(1);
00165   return res;
00166 }
00167 
00168 } // end namespace Eigen
00169 
00170 #endif // EIGEN_SCALING_H
 All Classes Functions Variables Typedefs Enumerations Enumerator Friends