Eigen::UniformScaling< Scalar_ > Class Template Reference

Represents a generic uniform scaling transformation. More...

#include <Scaling.h>

Public Types
typedef Scalar_	Scalar

Public Member Functions
	UniformScaling ()
	UniformScaling (const Scalar &s)
const Scalar &	factor () const
Scalar &	factor ()
UniformScaling	operator* (const UniformScaling &other) const
template<int Dim>
Transform< Scalar, Dim, Affine >	operator* (const Translation< Scalar, Dim > &t) const
template<int Dim, int Mode, int Options>
internal::uniformscaling_times_affine_returntype< Scalar, Dim, Mode >::type	operator* (const Transform< Scalar, Dim, Mode, Options > &t) const
template<typename Derived >
Eigen::internal::plain_matrix_type< Derived >::type	operator* (const MatrixBase< Derived > &other) const
template<typename Derived , int Dim>
Matrix< Scalar, Dim, Dim >	operator* (const RotationBase< Derived, Dim > &r) const
UniformScaling	inverse () const
template<typename NewScalarType >
UniformScaling< NewScalarType >	cast () const
template<typename OtherScalarType >
	UniformScaling (const UniformScaling< OtherScalarType > &other)
bool	isApprox (const UniformScaling &other, const typename NumTraits< Scalar >::Real &prec=NumTraits< Scalar >::dummy_precision()) const

Protected Attributes
Scalar	m_factor

Related Functions
(Note that these are not member functions.)
template<typename Derived , typename Scalar >
	operator* (const MatrixBase< Derived > &matrix, const UniformScaling< Scalar > &s)

Detailed Description

template<typename Scalar_>
class Eigen::UniformScaling< Scalar_ >

Represents a generic uniform scaling transformation.

\geometry_module

Template Parameters

Scalar_

the scalar type, i.e., the type of the coefficients.

This class represent a uniform scaling transformation. It is the return type of Scaling(Scalar), and most of the time this is the only way it is used. In particular, this class is not aimed to be used to store a scaling transformation, but rather to make easier the constructions and updates of Transform objects.

To represent an axis aligned scaling, use the DiagonalMatrix class.

See also

Scaling(), class DiagonalMatrix, MatrixBase::asDiagonal(), class Translation, class Transform

Member Typedef Documentation

Scalar

template<typename Scalar_ >

typedef Scalar_ Eigen::UniformScaling< Scalar_ >::Scalar

the scalar type of the coefficients

Constructor & Destructor Documentation

UniformScaling() [1/3]

template<typename Scalar_ >

Eigen::UniformScaling< Scalar_ >::UniformScaling ( )

inline

Default constructor without initialization.

{}

Referenced by Eigen::UniformScaling< Scalar_ >::inverse(), and Eigen::UniformScaling< Scalar_ >::operator*().

UniformScaling() [2/3]

template<typename Scalar_ >

Eigen::UniformScaling< Scalar_ >::UniformScaling ( const Scalar &  s )

inlineexplicit

Constructs and initialize a uniform scaling transformation

: m_factor(s) {}

UniformScaling() [3/3]

template<typename Scalar_ >

template<typename OtherScalarType >

Eigen::UniformScaling< Scalar_ >::UniformScaling ( const UniformScaling< OtherScalarType > &  other )

inlineexplicit

Copy constructor with scalar type conversion

                                                                               {
    m_factor = Scalar(other.factor());
  }

References Eigen::UniformScaling< Scalar_ >::factor(), and Eigen::UniformScaling< Scalar_ >::m_factor.

Member Function Documentation

cast()

template<typename Scalar_ >

template<typename NewScalarType >

UniformScaling<NewScalarType> Eigen::UniformScaling< Scalar_ >::cast ( ) const

inline

Returns

*this with scalar type casted to NewScalarType

Note that if NewScalarType is equal to the current scalar type of *this then this function smartly returns a const reference to *this.

                                                    {
    return UniformScaling<NewScalarType>(NewScalarType(m_factor));
  }

References Eigen::UniformScaling< Scalar_ >::m_factor.

factor() [1/2]

template<typename Scalar_ >

Scalar& Eigen::UniformScaling< Scalar_ >::factor ( )

inline

{ return m_factor; }

References Eigen::UniformScaling< Scalar_ >::m_factor.

factor() [2/2]

template<typename Scalar_ >

const Scalar& Eigen::UniformScaling< Scalar_ >::factor ( ) const

inline

{ return m_factor; }

References Eigen::UniformScaling< Scalar_ >::m_factor.

Referenced by Eigen::UniformScaling< Scalar_ >::isApprox(), Eigen::UniformScaling< Scalar_ >::operator*(), Eigen::Translation< Scalar_, Dim_ >::operator*(), and Eigen::UniformScaling< Scalar_ >::UniformScaling().

inverse()

template<typename Scalar_ >

UniformScaling Eigen::UniformScaling< Scalar_ >::inverse ( ) const

inline

Returns

the inverse scaling

{ return UniformScaling(Scalar(1) / m_factor); }

References Eigen::UniformScaling< Scalar_ >::m_factor, and Eigen::UniformScaling< Scalar_ >::UniformScaling().

isApprox()

template<typename Scalar_ >

bool Eigen::UniformScaling< Scalar_ >::isApprox ( const UniformScaling< Scalar_ > &  other, const typename NumTraits< Scalar >::Real &  prec = NumTraits<Scalar>::dummy_precision()  ) const

inline

Returns

true if *this is approximately equal to other, within the precision determined by prec.

See also

MatrixBase::isApprox()

                                                                                                       {
    return internal::isApprox(m_factor, other.factor(), prec);
  }

References Eigen::UniformScaling< Scalar_ >::factor(), Eigen::internal::isApprox(), and Eigen::UniformScaling< Scalar_ >::m_factor.

operator*() [1/5]

template<typename Scalar_ >

template<typename Derived >

Eigen::internal::plain_matrix_type<Derived>::type Eigen::UniformScaling< Scalar_ >::operator* ( const MatrixBase< Derived > &  other ) const

inline

Concatenates a uniform scaling and a linear transformation matrix

                                                                                                                {
    return other * m_factor;
  }

References Eigen::UniformScaling< Scalar_ >::m_factor.

operator*() [2/5]

template<typename Scalar_ >

template<typename Derived , int Dim>

Matrix<Scalar, Dim, Dim> Eigen::UniformScaling< Scalar_ >::operator* ( const RotationBase< Derived, Dim > &  r ) const

inline

                                                                                       {
    return r.toRotationMatrix() * m_factor;
  }

References Eigen::UniformScaling< Scalar_ >::m_factor, and UniformPSDSelfTest::r.

operator*() [3/5]

template<typename Scalar_ >

template<int Dim, int Mode, int Options>

internal::uniformscaling_times_affine_returntype<Scalar, Dim, Mode>::type Eigen::UniformScaling< Scalar_ >::operator* ( const Transform< Scalar, Dim, Mode, Options > &  t ) const

inline

Concatenates a uniform scaling and an affine transformation

                                                            {
    typename internal::uniformscaling_times_affine_returntype<Scalar, Dim, Mode>::type res = t;
    res.prescale(factor());
    return res;
  }

References Eigen::UniformScaling< Scalar_ >::factor(), res, and plotPSD::t.

operator*() [4/5]

template<typename Scalar >

template<int Dim>

Transform< Scalar, Dim, Affine > Eigen::UniformScaling< Scalar >::operator* ( const Translation< Scalar, Dim > &  t ) const

inline

Concatenates a uniform scaling and a translation

                                                                                                               {
  Transform<Scalar, Dim, Affine> res;
  res.matrix().setZero();
  res.linear().diagonal().fill(factor());
  res.translation() = factor() * t.vector();
  res(Dim, Dim) = Scalar(1);
  return res;
}

References Global_Variables::Dim, res, and plotPSD::t.

operator*() [5/5]

template<typename Scalar_ >

UniformScaling Eigen::UniformScaling< Scalar_ >::operator* ( const UniformScaling< Scalar_ > &  other ) const

inline

Concatenates two uniform scaling

                                                                     {
    return UniformScaling(m_factor * other.factor());
  }

References Eigen::UniformScaling< Scalar_ >::factor(), Eigen::UniformScaling< Scalar_ >::m_factor, and Eigen::UniformScaling< Scalar_ >::UniformScaling().

Friends And Related Function Documentation

operator*()

template<typename Derived , typename Scalar >

operator* ( const MatrixBase< Derived > &  matrix, const UniformScaling< Scalar > &  s  )

related

Concatenates a linear transformation matrix and a uniform scaling

                                                                              {
  return matrix.derived() * s.factor();
}

References matrix(), and s.

Member Data Documentation

m_factor

template<typename Scalar_ >

Scalar Eigen::UniformScaling< Scalar_ >::m_factor

protected

Referenced by Eigen::UniformScaling< Scalar_ >::cast(), Eigen::UniformScaling< Scalar_ >::factor(), Eigen::UniformScaling< Scalar_ >::inverse(), Eigen::UniformScaling< Scalar_ >::isApprox(), Eigen::UniformScaling< Scalar_ >::operator*(), and Eigen::UniformScaling< Scalar_ >::UniformScaling().

---

The documentation for this class was generated from the following files:

• ForwardDeclarations.h
• Eigen/src/Geometry/Scaling.h