目录
-
Eigen 库介绍
-
头文件分类总结
-
头文件函数 / 类用法及代码实例
-
机器人 SLAM 项目应用实例
-
机器人 SLAM 中常用函数和类总结
1. Eigen 库介绍
Eigen 库是一个用于 C++ 的强大线性代数库，旨在提供高效、类型安全且易于使用的矩阵和向量运算。它涵盖了从基础的矩阵操作到复杂的矩阵分解、几何变换等功能，广泛应用于计算机视觉、机器人学、数值分析、物理学模拟等领域，能极大地简化线性代数相关的编程任务，帮助开发者快速实现各种涉及矩阵运算的算法。
2. 头文件分类总结
-
基础运算：
-
- #include<Eigen/Core>：提供 Matrix 和 Array 类，用于基础的线性代数运算和数组操作。适用于各种简单的矩阵定义、元素访问以及基本的算术运算场景。
-
几何变换：
-
- #include<Eigen/Geometry>：包含平移、旋转、缩放等 2 维和 3 维的各种变换相关内容。常用于涉及物体空间姿态和位置变化的场景，如机器人运动控制、计算机图形学中的模型变换。
-
矩阵分解与求解：
-
- #include<Eigen/LU>：用于矩阵求逆、计算行列式以及 LU 分解。适用于求解一般线性方程组以及需要矩阵逆和行列式的场景。
-
- #include<Eigen/Cholesky>：通过豪斯霍尔德变换进行线性代数运算，常用于求解正定矩阵的线性方程组。
-
- #include<Eigen/SVD>：实现 SVD 分解，在数据降维、图像处理中的特征提取、信号处理等方面有广泛应用。
-
- #include<Eigen/QR>：进行 QR 分解，常用于求解线性最小二乘问题。
-
- #include<Eigen/Eigenvalues>：用于特征值和特征向量分解，在分析矩阵性质、稳定性以及振动问题等场景中发挥作用。
-
稀疏矩阵运算：
-
- #include<Eigen/Sparse>：提供稀疏矩阵的存储和一些基本的线性运算功能。适用于大规模矩阵且大部分元素为零的场景，可减少内存占用和计算量。
-
综合集成：
-
- #include<Eigen/Dense>：集成了 Core/Geometry/LU/Cholesky/SVD/QR/Eigenvalues 模块，适用于需要多种基础和高级矩阵运算的综合性场景。
-
- #include<Eigen/Eigen>：集成了 Dense 和 Sparse，是一个更全面的整合库，适用于项目中同时需要密集矩阵和稀疏矩阵相关功能的情况。
3. 头文件函数 / 类用法及代码实例
-
#include<Eigen/Core>：
-
- 矩阵和数组定义：
#include <Eigen/Core>
#include <iostream>
int main() {
Eigen::Matrix2i matrix2i;
matrix2i << 1, 2, 3, 4;
std::cout << "2x2 int matrix:\n" << matrix2i << std::endl;
Eigen::Array3f array3f;
array3f << 1.1f, 2.2f, 3.3f;
std::cout << "3 - element float array:\n" << array3f << std::endl;
return 0;
}
- 基本运算：
#include <Eigen/Core>
#include <iostream>
int main() {
Eigen::Matrix2d A, B;
A << 1, 2, 3, 4;
B << 5, 6, 7, 8;
Eigen::Matrix2d sum = A + B;
std::cout << "A + B:\n" << sum << std::endl;
Eigen::Array2d arr1, arr2;
arr1 << 1.0, 2.0;
arr2 << 3.0, 4.0;
Eigen::Array2d arrProduct = arr1 * arr2;
std::cout << "Array product:\n" << arrProduct << std::endl;
return 0;
}
-
#include<Eigen/Geometry>：
-
- 旋转和平移：
#include <Eigen/Geometry>
#include <iostream>
int main() {
Eigen::Quaterniond q(Eigen::AngleAxisd(M_PI / 2, Eigen::Vector3d::UnitZ()));
Eigen::Vector3d v(1, 0, 0);
Eigen::Vector3d rotatedV = q * v;
std::cout << "Rotated vector:\n" << rotatedV << std::endl;
Eigen::Translation3d t(1, 2, 3);
Eigen::Vector3d translatedV = t * v;
std::cout << "Translated vector:\n" << translatedV << std::endl;
return 0;
}
- 仿射变换：
#include <Eigen/Geometry>
#include <iostream>
int main() {
Eigen::Affine3d transform = Eigen::Affine3d::Identity();
transform.rotate(Eigen::AngleAxisd(M_PI / 2, Eigen::Vector3d::UnitZ()));
transform.translate(Eigen::Vector3d(1, 2, 3));
Eigen::Vector3d point(0, 0, 0);
Eigen::Vector3d transformedPoint = transform * point;
std::cout << "Transformed point:\n" << transformedPoint << std::endl;
return 0;
}
-
#include<Eigen/LU>：
-
- 矩阵求逆与行列式：
#include <Eigen/Dense>
#include <Eigen/LU>
#include <iostream>
int main() {
Eigen::Matrix3d A;
A << 1, 2, 3, 4, 5, 6, 7, 8, 9;
Eigen::Matrix3d inverseA = A.inverse();
std::cout << "Inverse of A:\n" << inverseA << std::endl;
double detA = A.determinant();
std::cout << "Determinant of A:\n" << detA << std::endl;
return 0;
}
- LU 分解求解线性方程组：
#include <Eigen/Dense>
#include <Eigen/LU>
#include <iostream>
int main() {
Eigen::Matrix3d A;
A << 1, 2, 3, 4, 5, 6, 7, 8, 9;
Eigen::Vector3d b;
b << 1, 2, 3;
Eigen::Vector3d x = A.lu().solve(b);
std::cout << "Solution of Ax = b:\n" << x << std::endl;
return 0;
}
- #include<Eigen/Cholesky>：
#include <Eigen/Dense>
#include <Eigen/Cholesky>
#include <iostream>
int main() {
Eigen::Matrix3d A;
A << 2, -1, 1, -1, 2, -1, 1, -1, 2;
Eigen::Vector3d b;
b << 1, 2, 3;
Eigen::Vector3d x = A.llt().solve(b);
std::cout << "Solution of Ax = b:\n" << x << std::endl;
return 0;
}
- #include<Eigen/SVD>：
#include <Eigen/Dense>
#include <Eigen/SVD>
#include <iostream>
int main() {
Eigen::Matrix3d A;
A << 1, 2, 3, 4, 5, 6, 7, 8, 9;
Eigen::JacobiSVD<Eigen::Matrix3d> svd(A, Eigen::ComputeThinU | Eigen::ComputeThinV);
std::cout << "Singular values:\n" << svd.singularValues() << std::endl;
std::cout << "U matrix:\n" << svd.matrixU() << std::endl;
std::cout << "V matrix:\n" << svd.matrixV() << std::endl;
return 0;
}
- #include<Eigen/QR>：
#include <Eigen/Dense>
#include <Eigen/QR>
#include <iostream>
int main() {
Eigen::Matrix3d A;
A << 1, 2, 3, 4, 5, 6, 7, 8, 9;
Eigen::Vector3d b;
b << 1, 2, 3;
Eigen::Vector3d x = A.colPivHouseholderQr().solve(b);
std::cout << "Solution of least squares problem:\n" << x << std::endl;
return 0;
}
- #include<Eigen/Eigenvalues>：
#include <Eigen/Dense>
#include <Eigen/Eigenvalues>
#include <iostream>
int main() {
Eigen::Matrix3d A;
A << 1, 2, 3, 4, 5, 6, 7, 8, 9;
Eigen::EigenSolver<Eigen::Matrix3d> eigenSolver(A);
std::cout << "Eigenvalues:\n" << eigenSolver.eigenvalues() << std::endl;
std::cout << "Eigenvectors:\n" << eigenSolver.eigenvectors() << std::endl;
return 0;
}
-
#include<Eigen/Sparse>：
-
- 稀疏矩阵定义与运算：
#include <Eigen/Sparse>
#include <iostream>
#include <Eigen/Dense>
int main() {
Eigen::SparseMatrix<double> sparseMatrix(3, 3);
sparseMatrix.insert(0, 0) = 1;
sparseMatrix.insert(1, 1) = 2;
sparseMatrix.insert(2, 2) = 3;
Eigen::Vector3d vector;
vector << 1, 2, 3;
Eigen::Vector3d result = sparseMatrix * vector;
std::cout << "Sparse matrix * vector:\n" << result << std::endl;
return 0;
}
-
#include<Eigen/Dense>：
-
- 综合运算示例：
#include <Eigen/Dense>
#include <iostream>
int main() {
Eigen::Matrix3d A;
A << 1, 2, 3, 4, 5, 6, 7, 8, 9;
Eigen::Vector3d b;
b << 1, 2, 3;
// 矩阵乘法
Eigen::Matrix3d product = A * A;
std::cout << "A * A:\n" << product << std::endl;
// 求解线性方程组
Eigen::Vector3d x = A.colPivHouseholderQr().solve(b);
std::cout << "Solution of Ax = b:\n" << x << std::endl;
return 0;
}
-
#include<Eigen/Eigen>：
-
- 密集与稀疏矩阵混合使用：
#include <Eigen/Eigen>
#include <iostream>
int main() {
Eigen::SparseMatrix<double> sparseMatrix(3, 3);
sparseMatrix.insert(0, 0) = 1;
sparseMatrix.insert(1, 1) = 2;
sparseMatrix.insert(2, 2) = 3;
Eigen::Matrix3d denseMatrix;
denseMatrix << 1, 2, 3, 4, 5, 6, 7, 8, 9;
Eigen::Vector3d vector;
vector << 1, 2, 3;
Eigen::Vector3d sparseResult = sparseMatrix * vector;
std::cout << "Sparse matrix * vector:\n" << sparseResult << std::endl;
Eigen::Vector3d denseResult = denseMatrix * vector;
std::cout << "Dense matrix * vector:\n" << denseResult << std::endl;
return 0;
}
4. 机器人 SLAM 项目应用实例
在一个基于视觉惯性融合的机器人 SLAM 项目中，机器人通过摄像头和惯性测量单元（IMU）获取数据。利用#include<Eigen/Geometry>中的旋转和平移变换来融合 IMU 测量的姿态信息和摄像头的位姿估计。通过#include<Eigen/Dense>中的矩阵运算，处理视觉特征点的坐标变换，将不同帧的特征点统一到同一坐标系下。在优化位姿图时，使用#include<Eigen/Cholesky>或#include<Eigen/LU>来求解线性方程组，以最小化重投影误差和姿态误差。
5. 机器人 SLAM 中常用函数和类总结
在机器人 SLAM 中，#include<Eigen/Geometry>中的Quaterniond（四元数表示旋转）、Affine3d（三维仿射变换）；#include<Eigen/Dense>中的MatrixXd（动态大小矩阵）、VectorXd（动态大小向量）使用频率较高。Quaterniond用于高效表示和处理机器人的旋转姿态，Affine3d能简洁地描述机器人的完整位姿。MatrixXd和VectorXd则广泛用于点云数据处理、坐标变换、误差计算以及优化过程中的矩阵操作，是实现各种 SLAM 算法的基础数据结构和运算工具。
拓展知识：到底什么场景下用哪个头文件，比如<Eigen/Eigen>里面集成了 Dense 和 Sparse，那我什么时候用Dense、Eigen或者Core呢？
- #include<Eigen/Core>
-
- 矩阵和数组基础操作场景：当你仅需要进行简单的矩阵和数组定义、初始化，以及基本的算术运算，如矩阵的加减乘除、数组元素的访问与简单操作时，使用#include<Eigen/Core>就足够了。例如，在一个简单的数学计算模块中，只涉及到二维矩阵的加法和乘法，就无需引入更复杂的模块。
-
- 轻量级计算需求：如果你的项目对性能要求较高，且只需要最基础的线性代数功能，引入#include<Eigen/Core>能减少不必要的库加载，提高编译速度。比如在一个对内存和编译时间敏感的嵌入式系统中，用于处理一些简单的传感器数据矩阵运算。
- #include<Eigen/Dense>
-
- 综合性矩阵运算场景：当项目中需要同时进行多种不同类型的矩阵运算，如不仅有基础的矩阵运算，还涉及到几何变换、矩阵分解求解等操作时，#include<Eigen/Dense>是一个很好的选择。例如在一个计算机视觉项目中，既要对图像特征点进行坐标变换（涉及几何变换），又要通过矩阵分解求解一些优化问题。
-
- 复杂算法实现：在实现如机器学习算法、物理模拟算法等复杂算法时，这些算法通常需要多种线性代数运算的组合。以实现一个基于梯度下降的优化算法为例，其中既需要矩阵乘法来计算梯度，又可能需要通过 LU 分解来求解线性方程组。
- #include<Eigen/Eigen>
-
- 密集矩阵与稀疏矩阵混合使用场景：如果你的项目中既存在大量常规的密集矩阵运算，又有部分大规模且稀疏的矩阵需要处理，那么#include<Eigen/Eigen>可以满足需求。例如在一个大规模的有限元分析项目中，部分矩阵描述结构的刚度等特性是稀疏矩阵，而在一些中间计算步骤和数据处理中又涉及到常规的密集矩阵运算。
-
- 代码简洁性需求：当你希望减少代码中#include语句的数量，使代码结构看起来更简洁，且项目确实需要#include<Eigen/Dense>和#include<Eigen/Sparse>的功能时，使用#include<Eigen/Eigen>能达到这个目的。但需要注意，这种方式可能会稍微增加编译时间，因为引入了更多的代码。
扫一扫
104
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
