 |
|
|
|
Modules | |
| Global aligned box typedefs | |
Classes | |
| 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::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::ParametrizedLine< Scalar_, AmbientDim_, Options_ > |
| A parametrized line. More... | |
| class | Eigen::QuaternionBase< Derived > |
| Base class for quaternion expressions. More... | |
| class | Eigen::Quaternion< Scalar_, Options_ > |
| The quaternion class used to represent 3D orientations and rotations. More... | |
| class | Eigen::Rotation2D< Scalar_ > |
| Represents a rotation/orientation in a 2 dimensional space. More... | |
| class | Eigen::UniformScaling< Scalar_ > |
| 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... | |
| 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 AngleAxis<double> Eigen::AngleAxisd |
double precision angle-axis type
| typedef AngleAxis<float> Eigen::AngleAxisf |
single precision angle-axis type
| 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 |
double precision quaternion type
| typedef Quaternion<float> Eigen::Quaternionf |
single precision quaternion type
| typedef Map<Quaternion<double>, Aligned> Eigen::QuaternionMapAlignedd |
Map a 16-byte aligned array of double precision scalars as a quaternion
| typedef Map<Quaternion<float>, Aligned> Eigen::QuaternionMapAlignedf |
Map a 16-byte aligned array of single precision scalars as a quaternion
| typedef Map<Quaternion<double>, 0> Eigen::QuaternionMapd |
Map an unaligned array of double precision scalars as a quaternion
| typedef Map<Quaternion<float>, 0> Eigen::QuaternionMapf |
Map an unaligned array of single precision scalars as a quaternion
| typedef Rotation2D<double> Eigen::Rotation2Dd |
double precision 2D rotation type
| typedef Rotation2D<float> Eigen::Rotation2Df |
single precision 2D rotation type
|
inline |
\geometry_module
*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:
"2" represents the z axis and "0" the x axis, etc. The returned angles are such that we have the following equality:
This corresponds to the right-multiply conventions (with right hand side frames).
For Tait-Bryan angle configurations (a0 != a2), the returned angles are in the ranges [-pi:pi]x[-pi/2:pi/2]x[-pi:pi]. For proper Euler angle configurations (a0 == a2), the returned angles are in the ranges [-pi:pi]x[0:pi]x[-pi:pi].
The approach used is also described here: https://d3cw3dd2w32x2b.cloudfront.net/wp-content/uploads/2012/07/euler-angles.pdf
References Eigen::numext::atan2(), Eigen::numext::cos(), EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE, i, j, k, res, and Eigen::numext::sin().
| EIGEN_DEVICE_FUNC const VectorwiseOp< ExpressionType, Direction >::CrossReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::cross | ( | const MatrixBase< OtherDerived > & | other | ) | const |
\geometry_module
The referenced matrix must have one dimension equal to 3. The result matrix has the same dimensions than the referenced one.
References cols, eigen_assert, EIGEN_STATIC_ASSERT, EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE, res, rows, and Eigen::Vertical.
| EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::cross_impl<Derived, OtherDerived>::return_type Eigen::MatrixBase< Derived >::cross | ( | const MatrixBase< OtherDerived > & | other | ) | const |
\geometry_module
*this and other. This is either a scalar for size-2 vectors or a size-3 vector for size-3 vectors.This method is implemented for two different cases: between vectors of fixed size 2 and between vectors of fixed size 3.
For vectors of size 3, the output is simply the traditional cross product.
For vectors of size 2, the output is a scalar. Given vectors \( v = \begin{bmatrix} v_1 & v_2 \end{bmatrix} \) and \( w = \begin{bmatrix} w_1 & w_2 \end{bmatrix} \), the result is simply \( v\times w = \overline{v_1 w_2 - v_2 w_1} = \text{conj}\left|\begin{smallmatrix} v_1 & w_1 \\ v_2 & w_2 \end{smallmatrix}\right| \); or, to put it differently, it is the third coordinate of the cross product of \( \begin{bmatrix} v_1 & v_2 & v_3 \end{bmatrix} \) and \( \begin{bmatrix} w_1 & w_2 & w_3 \end{bmatrix} \). For real-valued inputs, the result can be interpreted as the signed area of a parallelogram spanned by the two vectors.
\[ (\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}).\]
This definition preserves the orthogonality condition that \(\mathbf{u} \cdot (\mathbf{u} \times \mathbf{v}) = \mathbf{v} \cdot (\mathbf{u} \times \mathbf{v}) = 0\).References Eigen::internal::cross_impl< Derived, OtherDerived, Size >::run().
|
inline |
\geometry_module
*this and other using only the x, y, and z coefficientsThe 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.
References EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE, and Eigen::run().
|
inline |
\geometry_module
*this using the convention defined by the triplet (a0,a1,a2)NB: The returned angles are in non-canonical ranges [0:pi]x[-pi:pi]x[-pi:pi]. For canonical Tait-Bryan/proper Euler ranges, use canonicalEulerAngles.
References Eigen::numext::atan2(), Eigen::numext::cos(), EIGEN_PI, EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE, i, j, k, res, and Eigen::numext::sin().
|
inline |
homogeneous normalization
\geometry_module
*this divided by that last coefficient.This can be used to convert homogeneous coordinates to affine coordinates.
It is essentially a shortcut for:
Example:
Output:
References EIGEN_STATIC_ASSERT_VECTOR_ONLY, and size.
|
inline |
column or row-wise homogeneous normalization
\geometry_module
*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:
Output:
References cols, Eigen::Horizontal, rows, and Eigen::Vertical.
|
inline |
\geometry_module
This can be used to convert affine coordinates to homogeneous coordinates.
\only_for_vectors
Example:
Output:
References EIGEN_STATIC_ASSERT_VECTOR_ONLY.
|
inline |
\geometry_module
This can be used to convert affine coordinates to homogeneous coordinates.
Example:
Output:
| 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.
\geometry_module
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.
| src | Source points \( \mathbf{x} = \left( x_1, \hdots, x_n \right) \). |
| dst | Destination points \( \mathbf{y} = \left( y_1, \hdots, y_n \right) \). |
| with_scaling | Sets \( c=1 \) when false is passed. |
\begin{align*} T = \begin{bmatrix} c\mathbf{R} & \mathbf{t} \\ \mathbf{0} & 1 \end{bmatrix} \end{align*}
minimizing the residual above. This transformation is always returned as an Eigen::Matrix.References calibrate::c, Eigen::DenseBase< Derived >::colwise(), EIGEN_STATIC_ASSERT, m, Eigen::internal::min_size_prefer_dynamic(), n, Eigen::DenseBase< Derived >::rowwise(), oomph::QuadTreeNames::S, calibrate::sigma, Eigen::VectorwiseOp< ExpressionType, Direction >::sum(), svd(), tmp, and Eigen::value.
Referenced by run_fixed_size_test(), and run_test().
|
inline |
\geometry_module
*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().
References EIGEN_STATIC_ASSERT_VECTOR_ONLY, and Eigen::internal::unitOrthogonal_selector< Derived, Size >::run().
1.9.1