提取Eigen中Matrix元素等基本操作：Identity()函数、head<n>()函数

最新推荐文章于 2025-07-25 16:34:31 发布
原创 最新推荐文章于 2025-07-25 16:34:31 发布 · 3.3w 阅读 · 60 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Eigen #数据结构

本文介绍了Eigen库中矩阵操作的几个关键点，包括如何正确提取矩阵特定元素，使用Identity()函数初始化单位矩阵，以及head&lt;n&gt;()函数用于提取向量前n个元素的方法。

1.对一个Eigen::Matrix3f类型的数据x，在想提取其第三行第一列元素时：

（1）使用x.row(2).col(0)操作并赋值给一个变量，提示不能将Eigen...类型值赋值过去；

（2）使用x(2,0)操作可以完成提出元素并赋值。

 

2.使用Identity()函数的作用：在定义变量时使用Eigen::Matrix4f x =  Eigen::Matrix4f::Identity();即用单位矩阵对x变量进行了初始化。（参考了https://blog.youkuaiyun.com/yang_q_x/article/details/52383289和https://blog.youkuaiyun.com/caomin1hao/article/details/81358911?utm_source=blogxgwz5）

 

3.head<n>()函数：对变量Eigen::Vector4f x进行x.head<n>()操作表示提取前n个元素。

 

 

Eigen常用函数
yanzhiwen2的博客
04-08 5739
#include <Eigen/Dense> // 基本用法 // Eigen // Matlab // 注释 x.size() // length(x) // 向量的长度 C.rows() // size(C,1) // 矩阵的行数 C.cols() ...
Eigen::MatrixXf::Indentity
qq_42181775的博客
08-21 212
Eigen 3.3.4版本：C++线性代数库精粹
最新发布
weixin_31459297的博客
07-25 895
Eigen库持续在更新和改进，每一个新版本都会带来新的特性和性能上的提升。以Eigen 3.3.4版本为例，这个版本更新了一些重要的特性，包括但不限于：性能提升：特别是在矩阵乘法和分解方面。新增的表达式模板，优化了内存使用和计算。支持了更多数据类型和更复杂的数学运算。
Eigen::Isometry3d和Matrix4d::Identity的区别
qq_69198927的博客
08-31 1108
是一个特殊的4x4矩阵，用于表示欧几里得空间中的刚体变换，即旋转和平移。它保证了距离的不变性，即变换前后点之间的距离保持不变。这对于许多物理和几何应用来说是非常重要的。它可以用于表示任何线性变换，包括旋转、平移、缩放和剪切等。但是，它没有保证距离的不变性，也没有提供专门的接口来操作旋转和平移。内部使用一个旋转矩阵和一个平移向量来存储变换，这使得操作和组合这些变换更加高效。都是在Eigen库中用于表示变换的类，但它们的用途和性质有所不同。如果你需要表示和操作刚体变换（即旋转和平移），那么。
Eigen库中的Identity()函数作用
LNSTOP的博客
07-19 8494
Identity()的使用说明
Eigen变换矩阵的几种用法Matrix4f、Affine3f
09-13 1619
【代码】Eigen变换矩阵的几种用法Matrix4f、Affine3f。
Eigen中矩阵相关的函数的意思
qq_61811027的博客
10-19 609
C.resize(rows,cols) //将C矩阵重新定义大小为rows x cols 的矩阵，但是假如其中C的大小不符合重新定义的矩阵将会出错，一般使用在动态定义矩阵中，如Matrix B;分别对应矩阵的转置矩阵，共轭矩阵，伴随矩阵，使用时也只需要在矩阵后面家“.transpose()”即可，如x.transpose()C.fill(num) //将矩阵C的数据全部改为num。
Eigen库使用
wokaowokaowokao12345的专栏
11-29 1万+
前言Eigen是一个高层次的C ++库，有效支持 得到的线性代数，矩阵和矢量运算，数值分析及其相关的算法。配置关于Eigen库的配置只需要在属性表包含目录中添加Eigen路径即可。 例子Example 1：#include <iostream> #include <Eigen/Dense>void main() { Eigen::MatrixXd m(2, 2); /
Eigen深入剖析Matrix（进阶一）
小怪物爱吹牛的博客
07-05 5435
Eigen是以线性代数和矩阵理论为基础的数值计算库。在Eigen中所有的矩阵和向量都是Matrix模板类的对象，向量只是一种特殊的矩阵，默认向量是列向量。Array类的很多操作与Matrix类似，所以本章中介绍的部分操作也适用于Array。
【自动驾驶】Eigen变换矩阵的几种用法Matrix4f、Affine3f、
u011754972的博客
01-20 1万+
Eigen变换矩阵的几种用法Matrix4f、Affine3f、
Eigen库 C++中的输出某个元素
马上毕业的小菜菜
12-14 857
Eigen库 C++中的输出某个元素
Eigen使用快速参考
hjwang1的专栏
03-13 802
转自：http://blog.youkuaiyun.com/yuxiangyunei/article/details/50220287 from：http://eigen.tuxfamily.org/dox/AsciiQuickReference.txt Eigen 矩阵定义 [cpp] view plain copy #include   
eigen基础操作
weixin_45561357的博客
02-24 3497
eigen基础操作
Eigen学习（六）高级初始化
热门推荐
Fearless的博客
04-05 4万+
本节介绍几个初始化矩阵的高级方法，会更具体的介绍逗号初始化的方法。同样会介绍如何得到特殊矩阵比如单位矩阵和零矩阵等。逗号初始化Eigen提供了一个逗号初始化方法可以让使用者方便的设置矩阵、向量及数组的所有元素。简单的列出所有的元素，从左上角开始，从左至右，从上到下即可，当然前提是指定对象的尺寸，如果输入的数据少了或者多了，Eigen会报错的。Matrix3f m; m &lt;&lt; 1, 2,...
【Eigen】学习Eigen的一些总结——快速入门指南（一）
qq_29504955的博客
01-23 2052
对Eigen快速入门指南的一些学习
Eigen库的基本使用说明
主要学习关于图像处理和SLAM领域
03-13 1万+
Eigen是基于线性代数的C ++模板库，主要用于矩阵，向量，数值求解器和相关算法。Ceres,G2O等项目均是基于Eigen。 1.支持整数、浮点数、复数，使用模板编程，可以为特殊的数据结构提供矩阵操作。 2.支持逐元素、分块、和整体的矩阵操作。 3.支持使用Intel MKL加速部分功能。 4.支持多线程稀疏矩阵支持良好， 5.支持常用几何运算，包括旋转矩阵、四元数、矩阵变换、角轴等等。OpenCV自带到Eigen的接口。 Eigen是基于线性代数的C ++模板库，主要用于矩阵，向量，数值求
C++开源矩阵计算工具——Eigen的简单用法（三）
逍遥子曰：
01-11 1万+
本节主要涉及Eigen的块操作以及QR分解，Eigen的QR分解非常绕人，搞了很久才搞明白是怎么回事，最后是一个使用Eigen的矩阵操作完成二维高斯拟合求取光点的代码例子，关于二维高斯拟合求取光点的详细内容可参考：http://blog.youkuaiyun.com/hjx_1000/article/details/8490653 1、矩阵的块操作         1）矩阵的块操作有两种使用方法，其定义形
C++矩阵库Eigen的用法
weixin_44977185的博客
08-18 1104
【代码】C++矩阵库Eigen的用法。
#include "WES-ICP.h" #include <cmath> #include <iostream> #include <Eigen/Geometry> #include <Sophus/SE3.hpp> #include <pcl/kdtree/kdtree_flann.h> // 构造函数 WES_ICP::WES_ICP() : max_icp_iterations_(50), max_outer_iterations_(10), max_inner_iterations_(5), p_norm_(2.5f), w_pTp_(0.5f), w_pTpln_(0.5f), final_transformation_(Eigen::Matrix4f::Identity()) {} // 设置参数 void WES_ICP::setParameters(int max_icp, int max_outer, int max_inner, float p/*, float w_pTp, float w_pTpln*/) // 权重为自动更新 { max_icp_iterations_ = max_icp; max_outer_iterations_ = max_outer; max_inner_iterations_ = max_inner; p_norm_ = p; //w_pTp_ = w_pTp; //w_pTpln_ = w_pTpln; } // 辅助函数：反对称矩阵 Eigen::Matrix3f WES_ICP::skew(const Eigen::Vector3f& v) { Eigen::Matrix3f mat; mat << 0, -v.z(), v.y(), v.z(), 0, -v.x(), -v.y(), v.x(), 0; return mat; } // 稀疏收缩函数（向量） Eigen::Vector3f WES_ICP::shrink(const Eigen::Vector3f& h, double p, double mu) { Eigen::Vector3f result; for (int i = 0; i < 3; ++i) { double abs_h = std::abs(h[i]); if (abs_h <= 1.0 / mu) { result[i] = 0.0; } else { result[i] = std::copysign(abs_h - 1.0 / mu, h[i]) * std::pow(abs_h, p - 1); } } return result; } // 稀疏收缩函数（标量） double WES_ICP::shrink(double h, double p, double mu) { double abs_h = std::abs(h); if (abs_h <= 1.0 / mu) { return 0.0; } else { return std::copysign(abs_h - 1.0 / mu, h) * std::pow(abs_h, p - 1); } } // 优化步骤 Eigen::Matrix4f WES_ICP::WES_ICP_Optimization( const pcl::PointCloud<pcl::PointXYZ>& source_cloud, const pcl::PointCloud<pcl::PointXYZ>& inter_cloud, const pcl::PointCloud<pcl::PointXYZ>& target_cloud, const pcl::PointCloud<pcl::Normal>& normals_cloud, const Eigen::VectorXf& d, float w1, float w2) { Eigen::Matrix<float, 6, 6> A = Eigen::Matrix<float, 6, 6>::Zero(); Eigen::Matrix<float, 6, 1> b = Eigen::Matrix<float, 6, 1>::Zero(); for (size_t i = 0; i < source_cloud.size(); ++i) { Eigen::Vector3f source_pt = source_cloud.points[i].getVector3fMap(); Eigen::Vector3f inter_pt = inter_cloud.points[i].getVector3fMap(); Eigen::Vector3f target_pt = target_cloud.points[i].getVector3fMap(); Eigen::Vector3f normal = normals_cloud.points[i].getNormalVector3fMap(); float d_i = d[i]; // 构造生成元矩阵G (4x6) Eigen::Matrix<float, 4, 6> G; G.setZero(); G.block<3, 3>(0, 0) = Eigen::Matrix3f::Identity(); G.block<3, 3>(0, 3) = -skew(source_pt); // 残差项 Eigen::Vector4f e1; e1.head<3>() = source_pt - inter_pt; e1(3) = 0.0; float e2 = (source_pt - target_pt).dot(normal) - d_i; // 雅可比矩阵 Eigen::Matrix<float, 4, 6> A1 = G; Eigen::Vector4f normal_hom(normal.x(), normal.y(), normal.z(), 0.0); Eigen::Matrix<float, 1, 6> A2 = normal_hom.transpose() * G; // 更新线性系统 A += w1 * A1.transpose() * A1 + w2 * A2.transpose() * A2; b -= w1 * A1.transpose() * e1 + w2 * A2.transpose() * e2; } // 求解 Eigen::Matrix<float, 6, 1> x = A.ldlt().solve(b); // 检查无效值并退出 if (x.hasNaN() || x.array().isInf().any()) { std::cerr << "WES optin result has Inf values." << std::endl; Eigen::Matrix4f Ti = Eigen::Matrix4f::Identity(); return Ti; } else { // 李代数到SE(3) Sophus::SE3f T_update = Sophus::SE3f::exp(x); return T_update.matrix(); } } // 主配准函数 Eigen::Matrix4f WES_ICP::align( const pcl::PointCloud<pcl::PointXYZ>& source_cloud, const pcl::PointCloud<pcl::PointXYZ>& target_cloud, const pcl::PointCloud<pcl::Normal>& target_normals) { if (source_cloud.empty() || target_cloud.empty()) { std::cerr << "Error: Empty input clouds!" << std::endl; return Eigen::Matrix4f::Identity(); } pcl::PointCloud<pcl::PointXYZ> move_points = source_cloud; pcl::PointCloud<pcl::PointXYZ> old_points = source_cloud; final_transformation_ = Eigen::Matrix4f::Identity(); // ADMM变量 const size_t num_points = source_cloud.size(); Eigen::MatrixXf lambda_pTp = Eigen::MatrixXf::Zero(3, num_points); Eigen::MatrixXf Z_pTp = Eigen::MatrixXf::Zero(3, num_points); Eigen::VectorXf lambda_pTpln = Eigen::VectorXf::Zero(num_points); Eigen::VectorXf Z_pTpln = Eigen::VectorXf::Zero(num_points); Eigen::VectorXf delta_pTpln = Eigen::VectorXf::Zero(num_points); float mu = 10.0; // 构建KD树 pcl::KdTreeFLANN<pcl::PointXYZ> kdtree; kdtree.setInputCloud(target_cloud.makeShared()); for (int icp = 0; icp < max_icp_iterations_; ++icp) { // 匹配点 std::vector<int> indices(1); std::vector<float> distances(1); pcl::PointCloud<pcl::PointXYZ> match_points; pcl::PointCloud<pcl::Normal> match_normals; for (size_t i = 0; i < move_points.size(); ++i) { if (kdtree.nearestKSearch(move_points[i], 1, indices, distances) <= 0) { continue; } int nearest_idx = indices[0]; match_points.push_back(target_cloud[nearest_idx]); match_normals.push_back(target_normals[nearest_idx]); } // 动态权重 float w_pTp = 2.0 / (1.0 + std::exp(max_icp_iterations_ - icp)); float w_pTpln = 1.0 - w_pTp; // ADMM外层循环 for (int outer = 0; outer < max_outer_iterations_; ++outer) { // ADMM内层循环 for (int inner = 0; inner < max_inner_iterations_; ++inner) { // 点对点收缩 Eigen::MatrixXf H_pTp = move_points.getMatrixXfMap(3, 4, 0).transpose() - match_points.getMatrixXfMap(3, 4, 0).transpose() + lambda_pTp / mu; for (size_t k = 0; k < num_points; ++k) { Z_pTp.col(k) = shrink(H_pTp.col(k), p_norm_, mu); } pcl::PointCloud<pcl::PointXYZ> inter_points; for (size_t k = 0; k < num_points; ++k) { Eigen::Vector3f pt = match_points[k].getVector3fMap() + Z_pTp.col(k) - lambda_pTp.col(k) / mu; inter_points.push_back(pcl::PointXYZ(pt.x(), pt.y(), pt.z())); } // 点对面收缩 Eigen::VectorXf H_pTpln(num_points); for (size_t k = 0; k < num_points; ++k) { H_pTpln(k) = match_normals[k].getNormalVector3fMap().dot( move_points[k].getVector3fMap() - match_points[k].getVector3fMap()); } H_pTpln += lambda_pTpln / mu; for (size_t k = 0; k < num_points; ++k) { Z_pTpln(k) = shrink(H_pTpln(k), p_norm_, mu); } Eigen::VectorXf inter_d = Z_pTpln - lambda_pTpln / mu; // 优化步骤 Eigen::Matrix4f T1 = WES_ICP_Optimization( move_points, inter_points, match_points, match_normals, inter_d, w_pTp, w_pTpln); // 更新变换 final_transformation_ = T1 * final_transformation_; pcl::transformPointCloud(move_points, move_points, T1); // 检查收敛 float dual_max = 0.0; for (size_t k = 0; k < num_points; ++k) { Eigen::Vector3f diff = old_points[k].getVector3fMap() - move_points[k].getVector3fMap(); float dual_pTpln = diff.dot(match_normals[k].getNormalVector3fMap()); float dual_pTp = diff.norm(); dual_max = std::max(dual_max, std::max(dual_pTpln, dual_pTp)); } old_points = move_points; if (dual_max < 1e-5) { break; } } // 更新拉格朗日乘子 Eigen::MatrixXf delta_pTp = move_points.getMatrixXfMap(3, 4, 0).transpose() - match_points.getMatrixXfMap(3, 4, 0).transpose() - Z_pTp; for (size_t k = 0; k < num_points; ++k) { delta_pTpln(k) = match_normals[k].getNormalVector3fMap().dot( move_points[k].getVector3fMap() - match_points[k].getVector3fMap()) - Z_pTpln(k); } lambda_pTp += mu * delta_pTp; lambda_pTpln += mu * delta_pTpln; } } return final_transformation_; } // 获取最终变换矩阵 Eigen::Matrix4f WES_ICP::getFinalTransformation() const { return final_transformation_; } 匹配点对获取部分添加距离约束和几何一致性约束
07-09
- **加权优化**：基于保留的点对，最小化加权距离函数： $$ \min_{\mathbf{R}, \mathbf{t}} \sum_{(\mathbf{p}_i, \mathbf{q}_j)} w_{ij} \| \mathbf{R} \mathbf{p}_i + \mathbf{t} - \mathbf{q}_j \|^2 $$ ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值