Eigen库

「爱情、让人受尽委屈。」 2022-04-18 06:49 353阅读 0赞

### 文章目录 ###

*   *  安装
     *  使用
     *   *   *  注意坑
         *  官方文档说明
     *  常用
     *   *  矩阵和向量的操作
         *  SVD求解
         *  Eigen 和 OpenCV的转化
         *  Eigen 和 doube\*之间的映射

## 安装 ##

*  ubuntu 中：`sudo apt-get install libeigen3-dev` ，安装完成之后可以在/usr/include/下存在eigen3文件夹，证明安装成功。里面会有三个文件，子目录eigen3/Eigen下的头文件其实是对于你编译工程来说唯一需要的。  
      
    
 *  如果上述方法不行(有的其他库依赖eigen版本不对)，直接去[官网下载][Link 1]对应版本即可，编译安装，cmake的时候可以指定安装路径(cmake … 之后最下面会有提示，根据提示重新cmake 一下，默认/usr/local/include)。
 *  查看使用的Eigen的版本：在`/Eigen/src/Core/util/Macros.h` 里面，比如3.2.92  
    ![在这里插入图片描述][20190930164131588.png]

## 使用 ##

#### 注意坑 ####

*  主要参考[官方说明文档][Link 2]

1.  所有矩阵的默认按列存储，可以参考Matrix类，都是以0 为起点。
2.  所有操作需要相同类型，否则需要进行显示转化，也禁止弄错维数
3.  \[\]限于vector， (）都可以，（index）取决于存储顺序
4.  [内存对齐问题][Link 3]

### 官方文档说明 ###

1.  总体介绍包括：各个模块的作用，各种矩阵、向量的类型，以及如何操作：  
    Chapters->Dense matrix and array manipulation(大部分普通操作都有) / ->Quick reference guide（Like cheatsheet）

![在这里插入图片描述][2019022715464469.png]

1.  查看typedef定义的常用的matrix和vector类型：  
    Chapters->Dense matrix and array manipulation->Reference->Global matrix typedefs
2.  查看类的成员信息，.h文件  
    Chapters->Dense matrix and array manipulation->Reference->每个module下有类的说明，最下面都有打开.h文件的快捷键，其他模块也在相应Reference下module里面。或者和Chapters同级目录下有Class List总的表，按首字母排序。

## 常用 ##

### 矩阵和向量的操作 ###

`cols()`：行数  
`rows()`：列数  
`size()`：元素的个数  
`resize(3,3)`：重定义矩阵大小，和动态矩阵连用

Eigen::MatrixXd R; // 刚开始可能不清楚定义多大的矩阵
        /* 操作得到行和列 */
        R.resize(1,9);
        R << 1,2,3,4,5,6,7,8,9;
        cout << R.rows()<< " ";  // 1
        cout << R.cols()<< " ";  // 9
        cout << R(0,2) << endl;  //3
    
        R.resize(3,3);
        cout << R.rows()<< " "; // 3
        cout << R.cols() << " "; // 3
        cout << R(2,2) << endl;  // 9

*  Eigen和matlab的操作对比

#include <Eigen/Dense> 
    // 基本用法 
    // Eigen // Matlab // 注释 
    x.size()          // length(x) // 向量的长度 
    C.rows()          // size(C,1) // 矩阵的行数 
    C.cols()          // size(C,2) // 矩阵的列数 
    x(i)              // x(i+1) // 访问向量元素（Matlab的下标从1开始计数） 
    C(i,j)            // C(i+1,j+1) // 访问矩阵元素 
        
    A << 1, 2, 3,     // 初始化A，元素也可以是矩阵，先按列堆叠，再按行堆叠。 
         4, 5, 6,       
         7, 8, 9;       
    B << A, A, A;     // B 是3个A水平排列 
    A.fill(10);       // 将A的所有元素填充为10 
      
    // Eigen // Matlab 注释 
    MatrixXd::Identity(rows,cols)               // eye(rows,cols) //单位矩阵 
    C.setIdentity(rows,cols)                    // C = eye(rows,cols) //单位矩阵 
    MatrixXd::Zero(rows,cols)                   // zeros(rows,cols) //全零矩阵 
    C.setZero(rows,cols)                        // C = zeros(rows,cols) //全零矩阵 
    MatrixXd::Ones(rows,cols)                   // ones(rows,cols) //全一矩阵 
    C.setOnes(rows,cols)                        // C = ones(rows,cols) //全一矩阵 
    MatrixXd::Random(rows,cols)                 // rand(rows,cols)*2-1 //MatrixXd::Random 返回范围为(-1, 1)的均匀分布的随机数 
    C.setRandom(rows,cols)                      // C = rand(rows,cols)*2-1 //返回范围为(-1, 1)的均匀分布的随机数 
    VectorXd::LinSpaced(size,low,high)          // linspace(low,high,size)' //返回size个等差数列，第一个数为low，最后一个数为high 
    v.setLinSpaced(size,low,high)               // v = linspace(low,high,size)' //返回size个等差数列，第一个数为low，最后一个数为high 
    VectorXi::LinSpaced(((hi-low)/step)+1,      // low:step:hi //以step为步长的等差数列。((hi-low)/step)+1为个数 
                        low,low+step*(size-1))  // 
      
      
    // Matrix 切片和块。下面列出的所有表达式都是可读/写的。 
    // 使用模板参数更快（如第2个）。注意：Matlab是的下标是从1开始的。 
    // Eigen // Matlab // 注释 
    x.head(n)                          // x(1:n) //前n个元素 
    x.head<n>()                        // x(1:n) //前n个元素 
    x.tail(n)                          // x(end - n + 1: end) //倒数n个元素 
    x.tail<n>()                        // x(end - n + 1: end) //倒数n个元素 
    x.segment(i, n)                    // x(i+1 : i+n) //切片 
    x.segment<n>(i)                    // x(i+1 : i+n) //切片 
    P.block(i, j, rows, cols)          // P(i+1 : i+rows, j+1 : j+cols) //块 
    P.block<rows, cols>(i, j)          // P(i+1 : i+rows, j+1 : j+cols) //块 
    P.row(i)                           // P(i+1, :) //第i行 
    P.col(j)                           // P(:, j+1) //第j列 
    P.leftCols<cols>()                 // P(:, 1:cols) //前cols列 
    P.leftCols(cols)                   // P(:, 1:cols) //前cols列 
    P.middleCols<cols>(j)              // P(:, j+1:j+cols) //中间cols列 
    P.middleCols(j, cols)              // P(:, j+1:j+cols) //中间cols列 
    P.rightCols<cols>()                // P(:, end-cols+1:end) //后cols列 
    P.rightCols(cols)                  // P(:, end-cols+1:end) //后cols列 
    P.topRows<rows>()                  // P(1:rows, :) //前rows行 
    P.topRows(rows)                    // P(1:rows, :) //前rows行 
    P.middleRows<rows>(i)              // P(i+1:i+rows, :) //中间rows行 
    P.middleRows(i, rows)              // P(i+1:i+rows, :) //中间rows行 
    P.bottomRows<rows>()               // P(end-rows+1:end, :) //最后rows行 
    P.bottomRows(rows)                 // P(end-rows+1:end, :) //最后rows行 
    P.topLeftCorner(rows, cols)        // P(1:rows, 1:cols) //左上角块 
    P.topRightCorner(rows, cols)       // P(1:rows, end-cols+1:end) //右上角块 
    P.bottomLeftCorner(rows, cols)     // P(end-rows+1:end, 1:cols) //左下角块 
    P.bottomRightCorner(rows, cols)    // P(end-rows+1:end, end-cols+1:end) //右下角块 
    P.topLeftCorner<rows,cols>()       // P(1:rows, 1:cols) //左上角块 
    P.topRightCorner<rows,cols>()      // P(1:rows, end-cols+1:end) //右上角块 
    P.bottomLeftCorner<rows,cols>()    // P(end-rows+1:end, 1:cols) //左下角块 
    P.bottomRightCorner<rows,cols>()   // P(end-rows+1:end, end-cols+1:end) //右下角块 
      
      
    // 特别说明：Eigen的交换函数进行了高度优化 
    // Eigen // Matlab 
    R.row(i) = P.col(j);               // R(i, :) = P(:, j) 
    R.col(j1).swap(mat1.col(j2));      // R(:, [j1 j2]) = R(:, [j2, j1]) //交换列 
      
      
    // Views, transpose, etc; 
    // Eigen // Matlab 
    R.adjoint()                        // R' // 共轭转置 
    R.transpose()                      // R.' or conj(R') // 可读/写 转置 
    R.diagonal()                       // diag(R) // 可读/写 对角元素 
    x.asDiagonal()                     // diag(x) // 对角矩阵化 
    R.transpose().colwise().reverse()  // rot90(R) // 可读/写 逆时针旋转90度 
    R.rowwise().reverse()              // fliplr(R) // 水平翻转 
    R.colwise().reverse()              // flipud(R) // 垂直翻转 
    R.replicate(i,j)                   // repmat(P,i,j) // 复制矩阵，垂直复制i个，水平复制j个 
      
      
    // 四则运算，和Matlab相同。但Matlab中不能使用*=这样的赋值运算符 
    // 矩阵 - 向量 矩阵 - 矩阵 矩阵 - 标量 
    y  = M*x;          R  = P*Q;        R  = P*s;  
    a  = b*M;          R  = P - Q;      R  = s*P;  
    a *= M;            R  = P + Q;      R  = P/s;  
                       R *= Q;          R  = s*P;  
                       R += Q;          R *= s;  
                       R -= Q;          R /= s;  
      
      
    // 逐像素操作Vectorized operations on each element independently 
    // Eigen // Matlab //注释 
    R = P.cwiseProduct(Q);         // R = P .* Q //逐元素乘法 
    R = P.array() * s.array();     // R = P .* s //逐元素乘法（s为标量） 
    R = P.cwiseQuotient(Q);        // R = P ./ Q //逐元素除法 
    R = P.array() / Q.array();     // R = P ./ Q //逐元素除法 
    R = P.array() + s.array();     // R = P + s //逐元素加法（s为标量） 
    R = P.array() - s.array();     // R = P - s //逐元素减法（s为标量） 
    R.array() += s;                // R = R + s //逐元素加法（s为标量） 
    R.array() -= s;                // R = R - s //逐元素减法（s为标量） 
    R.array() < Q.array();         // R < Q //逐元素比较运算 
    R.array() <= Q.array();        // R <= Q //逐元素比较运算 
    R.cwiseInverse();              // 1 ./ P //逐元素取倒数 
    R.array().inverse();           // 1 ./ P //逐元素取倒数 
    R.array().sin()                // sin(P) //逐元素计算正弦函数 
    R.array().cos()                // cos(P) //逐元素计算余弦函数 
    R.array().pow(s)               // P .^ s //逐元素计算幂函数 
    R.array().square()             // P .^ 2 //逐元素计算平方 
    R.array().cube()               // P .^ 3 //逐元素计算立方 
    R.cwiseSqrt()                  // sqrt(P) //逐元素计算平方根 
    R.array().sqrt()               // sqrt(P) //逐元素计算平方根 
    R.array().exp()                // exp(P) //逐元素计算指数函数 
    R.array().log()                // log(P) //逐元素计算对数函数 
    R.cwiseMax(P)                  // max(R, P) //逐元素计算R和P的最大值 
    R.array().max(P.array())       // max(R, P) //逐元素计算R和P的最大值 
    R.cwiseMin(P)                  // min(R, P) //逐元素计算R和P的最小值 
    R.array().min(P.array())       // min(R, P) //逐元素计算R和P的最小值 
    R.cwiseAbs()                   // abs(P) //逐元素计算R和P的绝对值 
    R.array().abs()                // abs(P) //逐元素计算绝对值 
    R.cwiseAbs2()                  // abs(P.^2) //逐元素计算平方 
    R.array().abs2()               // abs(P.^2) //逐元素计算平方 
    (R.array() < s).select(P,Q );  // (R < s ? P : Q) //根据R的元素值是否小于s，选择P和Q的对应元素 
    R = (Q.array()==0).select(P,A) // R(Q==0) = P(Q==0) R(Q!=0) = P(Q!=0) //根据Q中元素等于零的位置选择P中元素 
    R = P.unaryExpr(ptr_fun(func)) // R = arrayfun(func, P) // 对P中的每个元素应用func函数 
      
      
    // Reductions. 
    int r, c;  
    // Eigen // Matlab //注释 
    R.minCoeff()              // min(R(:)) //最小值 
    R.maxCoeff()              // max(R(:)) //最大值 
    s = R.minCoeff(&r, &c)    // [s, i] = min(R(:)); [r, c] = ind2sub(size(R), i); //计算最小值和它的位置 
    s = R.maxCoeff(&r, &c)    // [s, i] = max(R(:)); [r, c] = ind2sub(size(R), i); //计算最大值和它的位置 
    R.sum()                   // sum(R(:)) //求和（所有元素） 
    R.colwise().sum()         // sum(R) //按列求和 
    R.rowwise().sum()         // sum(R, 2) or sum(R')' //按行求和 
    R.prod()                  // prod(R(:)) //累积 
    R.colwise().prod()        // prod(R) //按列累积 
    R.rowwise().prod()        // prod(R, 2) or prod(R')' //按行累积 
    R.trace()                 // trace(R) //迹 
    R.all()                   // all(R(:)) //是否所有元素都非零 
    R.colwise().all()         // all(R) //按列判断，是否该列所有元素都非零 
    R.rowwise().all()         // all(R, 2) //按行判断，是否该行所有元素都非零 
    R.any()                   // any(R(:)) //是否有元素非零 
    R.colwise().any()         // any(R) //按列判断，是否该列有元素都非零 
    R.rowwise().any()         // any(R, 2) //按行判断，是否该行有元素都非零 
      
      
    // 点积，范数等 
    // Eigen // Matlab // 注释 
    x.norm()                  // norm(x). //范数（注意：Eigen中没有norm(R)） 
    x.squaredNorm()           // dot(x, x) //平方和（注意：对于复数而言，不等价） 
    x.dot(y)                  // dot(x, y) //点积 
    x.cross(y)                // cross(x, y) //交叉积，需要头文件 #include <Eigen/Geometry> 
      
      
     类型转换 
    // Eigen // Matlab // 注释 
    A.cast<double>();         // double(A) //变成双精度类型 
    A.cast<float>();          // single(A) //变成单精度类型 
    A.cast<int>();            // int32(A) //编程整型 
    A.real();                 // real(A) //实部 
    A.imag();                 // imag(A) //虚部 
    // 如果变换前后的类型相同，不做任何事情。 
      
      
    // 注意：Eigen中，绝大多数的涉及多个操作数的运算都要求操作数具有相同的类型 
    MatrixXf F = MatrixXf::Zero(3,3);  
    A += F;                // 非法。Matlab中允许。（单精度+双精度） 
    A += F.cast<double>(); // 将F转换成double，并累加。（一般都是在使用时临时转换） 
      
      
    // Eigen 可以将已存储数据的缓存 映射成 Eigen矩阵 
    float array[3];  
    Vector3f::Map(array).fill(10);            // create a temporary Map over array and sets entries to 10 
    int data[4] = { 1, 2, 3, 4};  
    Matrix2i mat2x2(data);                    // 将 data 复制到 mat2x2 
    Matrix2i::Map(data) = 2*mat2x2;           // 使用 2*mat2x2 覆写data的元素 
    MatrixXi::Map(data, 2, 2) += mat2x2;      // 将 mat2x2 加到 data的元素上 (当编译时不知道大小时，可选语法)

--------------------

### SVD求解 ###

J = U Σ V ⊤ J=U\\Sigma V^\\top J=UΣV⊤

JacobiSVD<MatrixXd> svd(J, ComputeThinU | ComputeThinV);
        U = svd.matrixU();
        V = svd.matrixV();
        A = svd.singularValues(); // 对角线

--------------------

### Eigen 和 OpenCV的转化 ###

首先引入头文件<opencv2/core/eigen.hpp>，且它**放在Eigen头文件的后面**，否则报错

*  Eigen到OpenCV

Eigen::Matrix3d R;
        R << 1,2,3,4,5,6,7,8,9;
    
        Mat dst;
        eigen2cv(R, dst);

*  OpenCV到Eigen

Mat img = imread("../res/1.png", cv::IMREAD_GRAYSCALE); // 注意这里如果是彩色图，那么要么以灰度图读入，或者cos*3
        int rows = img.rows;
        int cols = img.cols;
    
        Eigen::MatrixXd eigenMat(rows,cols);
        cv2eigen(img, eigenMat);

--------------------

### Eigen 和 doube\*之间的映射 ###

1.  double\* 映射到 Vector

//全部映射
        double array[9] = { 1,2,3,4,5,6,7,8,9};
        VectorXd::ConstMapType xx(array, 9);
    
    	//只映射部分
    	double array[9] = { 1,2,3,4,5,6,7,8,9};
    	Eigen::Map<Vector3d> update(const_cast<double*>(update_)); // const_cast防止原来的数组不可变
    
    	//映射int型，需要int型的Eigen类型去接受
    	int array[9] = { 1,2,3,4,5,6,7,8,9};
        Eigen::Map<Vector3i>xx(array); // 1 2 3

注意：不能将int型数组强行转化为doube，因为double和int大小不一样，导致转化数组错误

1.  double\* 映射到 Matrix

// row major
    typedef Matrix<int, 3, 3, RowMajor> Matrix3I;
    int array[9] = { 1,2,3,4,5,6,7,8,9};
    Eigen::Map<Matrix3I>　xx　(array);
    //1 2 3
    //4 5 6
    //7 8 9
    
    // column major
    typedef Matrix<int, 3, 3, ColMajor> Matrix3I;
    int array[9] = { 1,2,3,4,5,6,7,8,9};
    Eigen::Map<Matrix3I>　xx　(array);
    //1 4 7
    //2 5 8
    //3 6 9
    
    
    
    // double都是一样的，改一下数据类型就好了
    
    
    //二维数组
    typedef Matrix<double, 3, 3, RowMajor> Matrix3D;
    double array[3][3] = { { 1,2,3},{ 4,5,6},{ 7,8,9}};
    Eigen::Map<Matrix3D>xx(*array);
    //1 2 3
    //4 5 6
    //7 8 9

[Link 1]: https://bitbucket.org/eigen/eigen/downloads/?tab=tags
[20190930164131588.png]: /images/20220418/1ab1e70e514b48d9b3e04e13fc0bff75.png
[Link 2]: http://eigen.tuxfamily.org/dox/
[Link 3]: http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html
[2019022715464469.png]: /images/20220418/850a4335de1a44c8acf2920899e1e96d.png