Modules | Classes | Typedefs | Functions
Geometry_Module
Geometry » Reference
Collaboration diagram for Geometry_Module:

Modules

 Global aligned box typedefs
 

Classes

class  Eigen::AlignedBox< _Scalar, _AmbientDim >
 An axis aligned box. More...
 
class  Eigen::AngleAxis< _Scalar >
 Represents a 3D rotation as a rotation angle around an arbitrary 3D axis. More...
 
class  Eigen::Homogeneous< MatrixType, _Direction >
 Expression of one (or a set of) homogeneous vector(s) More...
 
class  Eigen::Hyperplane< _Scalar, _AmbientDim, _Options >
 A hyperplane. More...
 
class  Eigen::Map< const Quaternion< _Scalar >, _Options >
 Quaternion expression mapping a constant memory buffer. More...
 
class  Eigen::Map< Quaternion< _Scalar >, _Options >
 Expression of a quaternion from a memory buffer. More...
 
class  Eigen::ParametrizedLine< _Scalar, _AmbientDim, _Options >
 A parametrized line. More...
 
class  Eigen::Quaternion< _Scalar, _Options >
 The quaternion class used to represent 3D orientations and rotations. More...
 
class  Eigen::QuaternionBase< Derived >
 Base class for quaternion expressions. More...
 
class  Eigen::Rotation2D< _Scalar >
 Represents a rotation/orientation in a 2 dimensional space. More...
 
class  Scaling
 Represents a generic uniform scaling transformation. More...
 
class  Eigen::Transform< _Scalar, _Dim, _Mode, _Options >
 Represents an homogeneous transformation in a N dimensional space. More...
 
class  Eigen::Translation< _Scalar, _Dim >
 Represents a translation transformation. More...
 

Typedefs

typedef Transform< double, 2, Affine > Eigen::Affine2d
 
typedef Transform< float, 2, Affine > Eigen::Affine2f
 
typedef Transform< double, 3, Affine > Eigen::Affine3d
 
typedef Transform< float, 3, Affine > Eigen::Affine3f
 
typedef Transform< double, 2, AffineCompact > Eigen::AffineCompact2d
 
typedef Transform< float, 2, AffineCompact > Eigen::AffineCompact2f
 
typedef Transform< double, 3, AffineCompact > Eigen::AffineCompact3d
 
typedef Transform< float, 3, AffineCompact > Eigen::AffineCompact3f
 
typedef DiagonalMatrix< double, 2 > Eigen::AlignedScaling2d
 
typedef DiagonalMatrix< float, 2 > Eigen::AlignedScaling2f
 
typedef DiagonalMatrix< double, 3 > Eigen::AlignedScaling3d
 
typedef DiagonalMatrix< float, 3 > Eigen::AlignedScaling3f
 
typedef AngleAxis< double > Eigen::AngleAxisd
 
typedef AngleAxis< float > Eigen::AngleAxisf
 
typedef Transform< double, 2, Isometry > Eigen::Isometry2d
 
typedef Transform< float, 2, Isometry > Eigen::Isometry2f
 
typedef Transform< double, 3, Isometry > Eigen::Isometry3d
 
typedef Transform< float, 3, Isometry > Eigen::Isometry3f
 
typedef Transform< double, 2, Projective > Eigen::Projective2d
 
typedef Transform< float, 2, Projective > Eigen::Projective2f
 
typedef Transform< double, 3, Projective > Eigen::Projective3d
 
typedef Transform< float, 3, Projective > Eigen::Projective3f
 
typedef Quaternion< double > Eigen::Quaterniond
 
typedef Quaternion< float > Eigen::Quaternionf
 
typedef Map< Quaternion< double >, Aligned > Eigen::QuaternionMapAlignedd
 
typedef Map< Quaternion< float >, Aligned > Eigen::QuaternionMapAlignedf
 
typedef Map< Quaternion< double >, 0 > Eigen::QuaternionMapd
 
typedef Map< Quaternion< float >, 0 > Eigen::QuaternionMapf
 
typedef Rotation2D< double > Eigen::Rotation2Dd
 
typedef Rotation2D< float > Eigen::Rotation2Df
 
typedef Translation< double, 2 > Eigen::Translation2d
 
typedef Translation< float, 2 > Eigen::Translation2f
 
typedef Translation< double, 3 > Eigen::Translation3d
 
typedef Translation< float, 3 > Eigen::Translation3f
 

Functions

template<typename OtherDerived >
EIGEN_DEVICE_FUNC MatrixBase< Derived >::template cross_product_return_type< OtherDerived >::type Eigen::MatrixBase< Derived >::cross (const MatrixBase< OtherDerived > &other) const
 
template<typename OtherDerived >
EIGEN_DEVICE_FUNC const CrossReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::cross (const MatrixBase< OtherDerived > &other) const
 
template<typename OtherDerived >
EIGEN_DEVICE_FUNC PlainObject Eigen::MatrixBase< Derived >::cross3 (const MatrixBase< OtherDerived > &other) const
 
EIGEN_DEVICE_FUNC Matrix< Scalar, 3, 1 > Eigen::MatrixBase< Derived >::eulerAngles (Index a0, Index a1, Index a2) const
 
EIGEN_DEVICE_FUNC const HNormalizedReturnType Eigen::MatrixBase< Derived >::hnormalized () const
 homogeneous normalization More...
 
EIGEN_DEVICE_FUNC const HNormalizedReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::hnormalized () const
 column or row-wise homogeneous normalization More...
 
EIGEN_DEVICE_FUNC HomogeneousReturnType Eigen::MatrixBase< Derived >::homogeneous () const
 
EIGEN_DEVICE_FUNC HomogeneousReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::homogeneous () const
 
template<typename Derived , typename Scalar >
 operator* (const MatrixBase< Derived > &matrix, const UniformScaling< Scalar > &s)
 
UniformScaling< float > Eigen::Scaling (float s)
 
UniformScaling< double > Eigen::Scaling (double s)
 
template<typename RealScalar >
UniformScaling< std::complex< RealScalar > > Eigen::Scaling (const std::complex< RealScalar > &s)
 
template<typename Scalar >
DiagonalMatrix< Scalar, 2 > Eigen::Scaling (const Scalar &sx, const Scalar &sy)
 
template<typename Scalar >
DiagonalMatrix< Scalar, 3 > Eigen::Scaling (const Scalar &sx, const Scalar &sy, const Scalar &sz)
 
template<typename Derived >
const DiagonalWrapper< const Derived > Eigen::Scaling (const MatrixBase< Derived > &coeffs)
 
template<typename Derived , typename OtherDerived >
internal::umeyama_transform_matrix_type< Derived, OtherDerived >::type Eigen::umeyama (const MatrixBase< Derived > &src, const MatrixBase< OtherDerived > &dst, bool with_scaling=true)
 Returns the transformation between two point sets. More...
 
EIGEN_DEVICE_FUNC PlainObject Eigen::MatrixBase< Derived >::unitOrthogonal (void) const
 

Detailed Description

Typedef Documentation

typedef Transform<double,2,Affine> Eigen::Affine2d

Definition at line 712 of file Transform.h.

typedef Transform<float,2,Affine> Eigen::Affine2f

Definition at line 708 of file Transform.h.

typedef Transform<double,3,Affine> Eigen::Affine3d

Definition at line 714 of file Transform.h.

typedef Transform<float,3,Affine> Eigen::Affine3f

Definition at line 710 of file Transform.h.

typedef Transform<double,2,AffineCompact> Eigen::AffineCompact2d

Definition at line 721 of file Transform.h.

typedef Transform<float,2,AffineCompact> Eigen::AffineCompact2f

Definition at line 717 of file Transform.h.

typedef Transform<double,3,AffineCompact> Eigen::AffineCompact3d

Definition at line 723 of file Transform.h.

typedef Transform<float,3,AffineCompact> Eigen::AffineCompact3f

Definition at line 719 of file Transform.h.

typedef DiagonalMatrix<double,2> Eigen::AlignedScaling2d
Deprecated:

Definition at line 148 of file Eigen/src/Geometry/Scaling.h.

typedef DiagonalMatrix<float, 2> Eigen::AlignedScaling2f
Deprecated:

Definition at line 146 of file Eigen/src/Geometry/Scaling.h.

typedef DiagonalMatrix<double,3> Eigen::AlignedScaling3d
Deprecated:

Definition at line 152 of file Eigen/src/Geometry/Scaling.h.

typedef DiagonalMatrix<float, 3> Eigen::AlignedScaling3f
Deprecated:

Definition at line 150 of file Eigen/src/Geometry/Scaling.h.

typedef AngleAxis<double> Eigen::AngleAxisd

double precision angle-axis type

Definition at line 160 of file AngleAxis.h.

typedef AngleAxis<float> Eigen::AngleAxisf

single precision angle-axis type

Definition at line 157 of file AngleAxis.h.

typedef Transform<double,2,Isometry> Eigen::Isometry2d

Definition at line 703 of file Transform.h.

typedef Transform<float,2,Isometry> Eigen::Isometry2f

Definition at line 699 of file Transform.h.

typedef Transform<double,3,Isometry> Eigen::Isometry3d

Definition at line 705 of file Transform.h.

typedef Transform<float,3,Isometry> Eigen::Isometry3f

Definition at line 701 of file Transform.h.

typedef Transform<double,2,Projective> Eigen::Projective2d

Definition at line 730 of file Transform.h.

typedef Transform<float,2,Projective> Eigen::Projective2f

Definition at line 726 of file Transform.h.

typedef Transform<double,3,Projective> Eigen::Projective3d

Definition at line 732 of file Transform.h.

typedef Transform<float,3,Projective> Eigen::Projective3f

Definition at line 728 of file Transform.h.

typedef Quaternion<double> Eigen::Quaterniond

double precision quaternion type

Definition at line 310 of file 3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h.

typedef Quaternion<float> Eigen::Quaternionf

single precision quaternion type

Definition at line 307 of file 3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h.

typedef Map<Quaternion<double>, Aligned> Eigen::QuaternionMapAlignedd

Map a 16-byte aligned array of double precision scalars as a quaternion

Definition at line 422 of file 3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h.

typedef Map<Quaternion<float>, Aligned> Eigen::QuaternionMapAlignedf

Map a 16-byte aligned array of single precision scalars as a quaternion

Definition at line 419 of file 3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h.

typedef Map<Quaternion<double>, 0> Eigen::QuaternionMapd

Map an unaligned array of double precision scalars as a quaternion

Definition at line 416 of file 3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h.

typedef Map<Quaternion<float>, 0> Eigen::QuaternionMapf

Map an unaligned array of single precision scalars as a quaternion

Definition at line 413 of file 3rdparty/Eigen/Eigen/src/Geometry/Quaternion.h.

typedef Rotation2D<double> Eigen::Rotation2Dd

double precision 2D rotation type

Definition at line 168 of file Rotation2D.h.

typedef Rotation2D<float> Eigen::Rotation2Df

single precision 2D rotation type

Definition at line 165 of file Rotation2D.h.

typedef Translation<double,2> Eigen::Translation2d

Definition at line 175 of file Translation.h.

typedef Translation<float, 2> Eigen::Translation2f

Definition at line 174 of file Translation.h.

typedef Translation<double,3> Eigen::Translation3d

Definition at line 177 of file Translation.h.

typedef Translation<float, 3> Eigen::Translation3f

Definition at line 176 of file Translation.h.

Function Documentation

template<typename Derived>
template<typename OtherDerived >
EIGEN_DEVICE_FUNC MatrixBase<Derived>::template cross_product_return_type<OtherDerived>::type Eigen::MatrixBase< Derived >::cross ( const MatrixBase< OtherDerived > &  other) const
inline
Returns
the cross product of *this and other

Here is a very good explanation of cross-product: http://xkcd.com/199/

With complex numbers, the cross product is implemented as $ (\mathbf{a}+i\mathbf{b}) \times (\mathbf{c}+i\mathbf{d}) = (\mathbf{a} \times \mathbf{c} - \mathbf{b} \times \mathbf{d}) - i(\mathbf{a} \times \mathbf{d} - \mathbf{b} \times \mathbf{c})$

See also
MatrixBase::cross3()

Definition at line 34 of file OrthoMethods.h.

template<typename ExpressionType , int Direction>
template<typename OtherDerived >
EIGEN_DEVICE_FUNC const VectorwiseOp< ExpressionType, Direction >::CrossReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::cross ( const MatrixBase< OtherDerived > &  other) const
Returns
a matrix expression of the cross product of each column or row of the referenced expression with the other vector.

The referenced matrix must have one dimension equal to 3. The result matrix has the same dimensions than the referenced one.

See also
MatrixBase::cross()

Definition at line 110 of file OrthoMethods.h.

template<typename Derived >
template<typename OtherDerived >
EIGEN_DEVICE_FUNC MatrixBase< Derived >::PlainObject Eigen::MatrixBase< Derived >::cross3 ( const MatrixBase< OtherDerived > &  other) const
inline
Returns
the cross product of *this and other using only the x, y, and z coefficients

The size of *this and other must be four. This function is especially useful when using 4D vectors instead of 3D ones to get advantage of SSE/AltiVec vectorization.

See also
MatrixBase::cross()

Definition at line 82 of file OrthoMethods.h.

template<typename Derived >
EIGEN_DEVICE_FUNC Matrix< typename MatrixBase< Derived >::Scalar, 3, 1 > Eigen::MatrixBase< Derived >::eulerAngles ( Index  a0,
Index  a1,
Index  a2 
) const
inline
Returns
the Euler-angles of the rotation matrix *this using the convention defined by the triplet (a0,a1,a2)

Each of the three parameters a0,a1,a2 represents the respective rotation axis as an integer in {0,1,2}. For instance, in:

Vector3f ea = mat.eulerAngles(2, 0, 2);

"2" represents the z axis and "0" the x axis, etc. The returned angles are such that we have the following equality:

mat == AngleAxisf(ea[0], Vector3f::UnitZ())
* AngleAxisf(ea[1], Vector3f::UnitX())
* AngleAxisf(ea[2], Vector3f::UnitZ());

This corresponds to the right-multiply conventions (with right hand side frames).

The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi].

See also
class AngleAxis

Definition at line 37 of file Eigen/src/Geometry/EulerAngles.h.

template<typename Derived >
EIGEN_DEVICE_FUNC const MatrixBase< Derived >::HNormalizedReturnType Eigen::MatrixBase< Derived >::hnormalized ( ) const
inline

homogeneous normalization

Returns
a vector expression of the N-1 first coefficients of *this divided by that last coefficient.

This can be used to convert homogeneous coordinates to affine coordinates.

It is essentially a shortcut for:

this->head(this->size()-1)/this->coeff(this->size()-1);

Example:

Vector4d v = Vector4d::Random();
Projective3d P(Matrix4d::Random());
cout << "v = " << v.transpose() << "]^T" << endl;
cout << "v.hnormalized() = " << v.hnormalized().transpose() << "]^T" << endl;
cout << "P*v = " << (P*v).transpose() << "]^T" << endl;
cout << "(P*v).hnormalized() = " << (P*v).hnormalized().transpose() << "]^T" << endl;

Output: 

See also
VectorwiseOp::hnormalized() 



Definition at line 172 of file Homogeneous.h.













template<typename ExpressionType , int Direction> 



  

  
      

        

          EIGEN_DEVICE_FUNC const VectorwiseOp< ExpressionType, Direction >::HNormalizedReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::hnormalized 
          (
          )
           const
        

      

  		
  
inline  
  







column or row-wise homogeneous normalization 


Returns
an expression of the first N-1 coefficients of each column (or row) of *this divided by the last coefficient of each column (or row).


This can be used to convert homogeneous coordinates to affine coordinates.


It is conceptually equivalent to calling MatrixBase::hnormalized() to each column (or row) of *this.


Example: 
typedef Matrix<double,4,Dynamic> Matrix4Xd;
Matrix4Xd M = Matrix4Xd::Random(4,5);
Projective3d P(Matrix4d::Random());
cout << "The matrix M is:" << endl << M << endl << endl;
cout << "M.colwise().hnormalized():" << endl << M.colwise().hnormalized() << endl << endl;
cout << "P*M:" << endl << P*M << endl << endl;
cout << "(P*M).colwise().hnormalized():" << endl << (P*M).colwise().hnormalized() << endl << endl;
 Output: 
See also
MatrixBase::hnormalized() 



Definition at line 196 of file Homogeneous.h.













template<typename Derived > 



  

  
      

        

          EIGEN_DEVICE_FUNC MatrixBase< Derived >::HomogeneousReturnType Eigen::MatrixBase< Derived >::homogeneous 
          (
          )
           const
        

      

  		
  
inline  
  






Returns
a vector expression that is one longer than the vector argument, with the value 1 symbolically appended as the last coefficient.


This can be used to convert affine coordinates to homogeneous coordinates.


Example: 
Vector3d v = Vector3d::Random(), w;
Projective3d P(Matrix4d::Random());
cout << "v                                   = [" << v.transpose() << "]^T" << endl;
cout << "h.homogeneous()                     = [" << v.homogeneous().transpose() << "]^T" << endl;
cout << "(P * v.homogeneous())               = [" << (P * v.homogeneous()).transpose() << "]^T" << endl;
cout << "(P * v.homogeneous()).hnormalized() = [" << (P * v.homogeneous()).eval().hnormalized().transpose() << "]^T" << endl;
 Output: 
See also
VectorwiseOp::homogeneous(), class Homogeneous 



Definition at line 130 of file Homogeneous.h.













template<typename ExpressionType , int Direction> 



  

  
      

        

          EIGEN_DEVICE_FUNC Homogeneous< ExpressionType, Direction > Eigen::VectorwiseOp< ExpressionType, Direction >::homogeneous 
          (
          )
           const
        

      

  		
  
inline  
  






Returns
an expression where the value 1 is symbolically appended as the final coefficient to each column (or row) of the matrix.


This can be used to convert affine coordinates to homogeneous coordinates.


Example: 
typedef Matrix<double,3,Dynamic> Matrix3Xd;
Matrix3Xd M = Matrix3Xd::Random(3,5);
Projective3d P(Matrix4d::Random());
cout << "The matrix M is:" << endl << M << endl << endl;
cout << "M.colwise().homogeneous():" << endl << M.colwise().homogeneous() << endl << endl;
cout << "P * M.colwise().homogeneous():" << endl << P * M.colwise().homogeneous() << endl << endl;
cout << "P * M.colwise().homogeneous().hnormalized(): " << endl << (P * M.colwise().homogeneous()).colwise().hnormalized() << endl << endl;
 Output: 
See also
MatrixBase::homogeneous(), class Homogeneous 



Definition at line 148 of file Homogeneous.h.













template<typename Derived , typename Scalar > 



  

  
      

        

          operator* 
          (
          const MatrixBase< Derived > & 
          matrix, 
        

        

          
          
          const UniformScaling< Scalar > & 
          s 
        

        

          
          )
          
        

      

  		
  
related  
  






Concatenates a linear transformation matrix and a uniform scaling 



Definition at line 117 of file Eigen/src/Geometry/Scaling.h.













  

  
      

        

          UniformScaling<float> Eigen::Scaling 
          (
          float 
          s)
          
        

      

  		
  
inline  
  






Constructs a uniform scaling from scale factor s 



Definition at line 121 of file Eigen/src/Geometry/Scaling.h.













  

  
      

        

          UniformScaling<double> Eigen::Scaling 
          (
          double 
          s)
          
        

      

  		
  
inline  
  






Constructs a uniform scaling from scale factor s 



Definition at line 123 of file Eigen/src/Geometry/Scaling.h.













template<typename RealScalar > 



  

  
      

        

          UniformScaling<std::complex<RealScalar> > Eigen::Scaling 
          (
          const std::complex< RealScalar > & 
          s)
          
        

      

  		
  
inline  
  






Constructs a uniform scaling from scale factor s 



Definition at line 126 of file Eigen/src/Geometry/Scaling.h.













template<typename Scalar > 



  

  
      

        

          DiagonalMatrix<Scalar,2> Eigen::Scaling 
          (
          const Scalar & 
          sx, 
        

        

          
          
          const Scalar & 
          sy 
        

        

          
          )
          
        

      

  		
  
inline  
  






Constructs a 2D axis aligned scaling 



Definition at line 131 of file Eigen/src/Geometry/Scaling.h.













template<typename Scalar > 



  

  
      

        

          DiagonalMatrix<Scalar,3> Eigen::Scaling 
          (
          const Scalar & 
          sx, 
        

        

          
          
          const Scalar & 
          sy, 
        

        

          
          
          const Scalar & 
          sz 
        

        

          
          )
          
        

      

  		
  
inline  
  






Constructs a 3D axis aligned scaling 



Definition at line 135 of file Eigen/src/Geometry/Scaling.h.













template<typename Derived > 



  

  
      

        

          const DiagonalWrapper<const Derived> Eigen::Scaling 
          (
          const MatrixBase< Derived > & 
          coeffs)
          
        

      

  		
  
inline  
  






Constructs an axis aligned scaling expression from vector expression coeffs This is an alias for coeffs.asDiagonal() 



Definition at line 142 of file Eigen/src/Geometry/Scaling.h.













template<typename Derived , typename OtherDerived > 

      

        

          internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type Eigen::umeyama 
          (
          const MatrixBase< Derived > & 
          src, 
        

        

          
          
          const MatrixBase< OtherDerived > & 
          dst, 
        

        

          
          
          bool 
          with_scaling = true 
        

        

          
          )
          
        

      





Returns the transformation between two point sets. 


The algorithm is based on: "Least-squares estimation of transformation parameters between two point patterns", Shinji Umeyama, PAMI 1991, DOI: 10.1109/34.88573


It estimates parameters $ c, \mathbf{R}, $ and $ \mathbf{t} $ such that 

\begin{align*} \frac{1}{n} \sum_{i=1}^n \vert\vert y_i - (c\mathbf{R}x_i + \mathbf{t}) \vert\vert_2^2 \end{align*}



 is minimized.


The algorithm is based on the analysis of the covariance matrix $ \Sigma_{\mathbf{x}\mathbf{y}} \in \mathbb{R}^{d \times d} $ of the input point sets $ \mathbf{x} $ and $ \mathbf{y} $ where $d$ is corresponding to the dimension (which is typically small). The analysis is involving the SVD having a complexity of $O(d^3)$ though the actual computational effort lies in the covariance matrix computation which has an asymptotic lower bound of $O(dm)$ when the input point sets have dimension $d \times m$.


Currently the method is working only for floating point matrices.


Todo:
Should the return type of umeyama() become a Transform?


Parameters

  

    
srcSource points $ \mathbf{x} = \left( x_1, \hdots, x_n \right) $. 

    
dstDestination points $ \mathbf{y} = \left( y_1, \hdots, y_n \right) $. 

    
with_scalingSets $ c=1 $ when false is passed. 

  

  




Returns
The homogeneous transformation 

\begin{align*} T = \begin{bmatrix} c\mathbf{R} & \mathbf{t} \\ \mathbf{0} & 1 \end{bmatrix} \end{align*}


 minimizing the resudiual above. This transformation is always returned as an Eigen::Matrix. 



Definition at line 95 of file Umeyama.h.













template<typename Derived > 



  

  
      

        

          EIGEN_DEVICE_FUNC MatrixBase< Derived >::PlainObject Eigen::MatrixBase< Derived >::unitOrthogonal 
          (
          void 
          )
           const
        

      

  		
  
inline  
  






Returns
a unit vector which is orthogonal to *this 


The size of *this must be at least 2. If the size is exactly 2, then the returned vector is a counter clock wise rotation of *this, i.e., (-y,x).normalized().


See also
cross() 



Definition at line 226 of file OrthoMethods.h.













gtsam

Author(s): 

autogenerated on Sat May 8 2021 02:51:44