逆矩阵介绍及C++/OpenCV/Eigen的三种实现

最新推荐文章于 2024-04-24 08:11:50 发布
最新推荐文章于 2024-04-24 08:11:50 发布
阅读量2w 收藏 44
点赞数 6
分类专栏： Math Knowledge Eigen/OpenBLAS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengbingchun/article/details/72571800
版权

逆矩阵(inverse matrix)：在线性代数中，给定一个n阶方阵A，若存在一n阶方阵B，使得AB = BA =In，其中In为n阶单位矩阵，则称A是可逆的，且B是A的逆矩阵，记作A-1.只有正方形(n*n)的矩阵，亦即方阵，才可能、但非必然有逆矩阵。若方阵A的逆矩阵存在，则称A为非奇异方阵或可逆方阵。与行列式类似，逆矩阵一般常用于求解包含数个变数的数学方程式。

线性方程组：Ax = b ,如下，其中A是一个已知矩阵，b是一个已知向量，x是我们要求解的未知向量。向量x的每一个元素xi都是未知的。矩阵A的每一行和b中对应的元素构成一个约束。


线性代数提供了被称为矩阵逆(matrix inversion)的强大工具，对于大多数矩阵A，我们都能通过矩阵逆解析地求解式Ax=b。

单位矩阵(identity matrix)：任意向量和单位矩阵相乘，都不会改变。我们将保持n维向量不变的单位矩阵记作In，形式上如下，

单位矩阵的结构很简单：所有沿主对角线的元素都是1，而所有其他位置的元素都是0。

矩阵A的矩阵逆(matrix inversion)记作A-1，其定义的矩阵满足如下条件：A-1A = In，可以通过A-1求解Ax = b，即x = A-1b。当然，这取决于我们能否找到一个逆矩阵A-1.

当逆矩阵A-1存在时，有几种不同的算法都能找到它的闭解形式。理论上，相同的逆矩阵可用于多次求解不同向量b的方程。

逆矩阵性质：

(1)、若矩阵A是可逆的，则A的逆矩阵是唯一的。

(2)、可逆矩阵一定是方阵。

(3)、A的逆矩阵的逆矩阵还是A，记作(A-1)-1=A.

(4)、可逆矩阵A的转置矩阵AT也可逆，并且(AT)-1=(A-1)T(转置的逆等于逆的转置)。

(5)、若矩阵A可逆，则矩阵A满足消去律，若AB=I(或BA=I)，则B=I，若AB=AC(或BA=CA)，则B=C。

(6)、两个可逆矩阵的乘积依然可逆。

(7)、矩阵可逆当且仅当它是满秩矩阵。

(8)、(λA)-1=(1/λ)*A-1

(9)、(AB)-1=B-1A-1

(10)、det(A-1)=1/det(A) (det为行列式)

(11)、方阵A可逆的充分必要条件是|A|≠0,并且A-1=(1/|A|)A*,其中A*是A的伴随矩阵。即可逆矩阵就是非奇异矩阵(当|A|=0时，A称为奇异矩阵)。

如果逆矩阵A-1存在，对于式Ax = b，肯定对于每一个向量b恰好存在一个解。

线性组合(linear combination)：形式上，一组向量的线性组合，是指每个向量乘以对应标量系数之后的和，即：


生成子空间(span)：一组向量的生成子空间是原始向量线性组合后所能抵达的点的集合。

确定Ax = b是否有解相当于确定向量b是否在A列向量的生成子空间中。这个特殊的生成子空间被称为A的列空间(column space)或者A的值域(range)。

线性无关(linearly independent)：如果一组向量中的任意一个向量都不能表示成其他向量的线性组合，那么这组向量被称为线性无关，反之称为线性相关(linearly  dependent)。如果某个向量是一组向量中某些向量的线性组合，那么我们将这个向量加入到这组向量后不会增加这组向量的生成子空间。这意味着，如果一个矩阵的列空间涵盖整个Rm,那么该矩阵必须包含至少一组m个线性无关的向量。这是式Ax = b对于每一个向量b的取值都有解的充分必要条件。值得注意的是，这个条件是说该向量集恰好有m个线性无关的列向量，而不是至少m个。不存在一个m维向量的集合具有多于m个彼此线性不相关的列向量，但是一个有多于m个列向量的矩阵却有可能拥有不止一个大小为m的线性无关向量集。

要想使矩阵可逆，我们还需要保证式Ax = b对于每一个b值至多有一个解。为此，我们需要确保该矩阵至多有m个列向量。否则，该方程会有不止一个解。

综上所述，这意味着该矩阵必须是一个方阵(square)，即m = n，并且所有列向量都是线性无关的。一个列向量线性相关的方阵被称为奇异的(singular)。

如果矩阵A不是一个方阵或者是一个奇异的方阵，该方程仍然可能有解。但是我们不能使用矩阵逆去求解。

对于方阵而言，矩阵的左逆和右逆是相等的：AA-1=A-1A=I

以上内容来自于 维基百科 和 《深度学习中文版》(https://github.com/exacity/deeplearningbook-chinese)

以下是分别用C++和OpenCV实现的矩阵求逆： 

#include "funset.hpp"
#include <math.h>
#include <iostream>
#include <string>
#include <vector>
#include <opencv2/opencv.hpp>
#include "common.hpp"

#define EXP 1.0e-5

// 计算行列式
template<typename _Tp>
_Tp determinant(const std::vector<std::vector<_Tp>>& mat, int N)
{
	if (mat.size() != N) {
		fprintf(stderr, "mat must be square matrix\n");
		return -1;
	}
	for (int i = 0; i < mat.size(); ++i) {
		if (mat[i].size() != N) {
			fprintf(stderr, "mat must be square matrix\n");
			return -1;
		}
	}

	_Tp ret{ 0 };

	if (N == 1) return mat[0][0];

	if (N == 2) {
		return (mat[0][0] * mat[1][1] - mat[0][1] * mat[1][0]);
	}
	else {
		// first col
		for (int i = 0; i < N; ++i) {
			std::vector<std::vector<_Tp>> m(N - 1);
			std::vector<int> m_rows;
			for (int t = 0; t < N; ++t) {
				if (i != t) m_rows.push_back(t);
			}
			for (int x = 0; x < N - 1; ++x) {
				m[x].resize(N - 1);
				for (int y = 0; y < N - 1; ++y) {
					m[x][y] = mat[m_rows[x]][y + 1];
				}
			}
			int sign = (int)pow(-1, 1 + i + 1);
			ret += mat[i][0] * sign * determinant<_Tp>(m, N - 1);
		}
	}

	return ret;
}

// 计算伴随矩阵
template<typename _Tp>
int adjoint(const std::vector<std::vector<_Tp>>& mat, std::vector<std::vector<_Tp>>& adj, int N)
{
	if (mat.size() != N) {
		fprintf(stderr, "mat must be square matrix\n");
		return -1;
	}
	for (int i = 0; i < mat.size(); ++i) {
		if (mat[i].size() != N) {
			fprintf(stderr, "mat must be square matrix\n");
			return -1;
		}
	}

	adj.resize(N);
	for (int i = 0; i < N; ++i) {
		adj[i].resize(N);
	}

	for (int y = 0; y < N; ++y) {
		std::vector<int> m_cols;
		for (int i = 0; i < N; ++i) {
			if (i != y) m_cols.push_back(i);
		}

		for (int x = 0; x < N; ++x) {
			std::vector<int> m_rows;
			for (int i = 0; i < N; ++i) {
				if (i != x) m_rows.push_back(i);
			}

			std::vector<std::vector<_Tp>> m(N - 1);
			for (int i = 0; i < N - 1; ++i) {
				m[i].resize(N - 1);
			}
			for (int j = 0; j < N - 1; ++j) {
				for (int i = 0; i < N - 1; ++i) {
					m[j][i] = mat[m_rows[j]][m_cols[i]];
				}
			}

			int sign = (int)pow(-1, x + y);
			adj[y][x] = sign * determinant<_Tp>(m, N-1);
		}
	}

	return 0;
}

template<typename _Tp>
void print_matrix(const std::vector<std::vector<_Tp>>& mat)
{
	int rows = mat.size();
	for (int y = 0; y < rows; ++y) {
		for (int x = 0; x < mat[y].size(); ++x) {
			fprintf(stderr, "  %f  ", mat[y][x]);
		}
		fprintf(stderr, "\n");
	}
	fprintf(stderr, "\n");
}

void print_matrix(const cv::Mat& mat)
{
	assert(mat.channels() == 1);

	for (int y = 0; y < mat.rows; ++y) {
		for (int x = 0; x < mat.cols; ++x) {
			if (mat.depth() == CV_8U) {
				unsigned char value = mat.at<uchar>(y, x);
				fprintf(stderr, "  %d  ", value);
			}
			else if (mat.depth() == CV_32F) {
				float value = mat.at<float>(y, x);
				fprintf(stderr, "  %f  ", value);
			}
			else if (mat.depth() == CV_64F) {
				double value = mat.at<double>(y, x);
				fprintf(stderr, "  %f  ", value);
			}
			else {
				fprintf(stderr, "don't support type: %d\n", mat.depth());
				return;
			}
		}
		fprintf(stderr, "\n");
	}
	fprintf(stderr, "\n");
}

// 求逆矩阵
template<typename _Tp>
int inverse(const std::vector<std::vector<_Tp>>& mat, std::vector<std::vector<_Tp>>& inv, int N)
{
	if (mat.size() != N) {
		fprintf(stderr, "mat must be square matrix\n");
		return -1;
	}
	for (int i = 0; i < mat.size(); ++i) {
		if (mat[i].size() != N) {
			fprintf(stderr, "mat must be square matrix\n");
			return -1;
		}
	}

	_Tp det = determinant(mat, N);
	if (fabs(det) < EXP) {
		fprintf(stderr, "mat's determinant don't equal 0\n");
		return -1;
	}

	inv.resize(N);
	for (int i = 0; i < N; ++i) {
		inv[i].resize(N);
	}

	double coef = 1.f / det;
	std::vector<std::vector<_Tp>> adj;
	if (adjoint(mat, adj, N) != 0) return -1;

	for (int y = 0; y < N; ++y) {
		for (int x = 0; x < N; ++x) {
			inv[y][x] = (_Tp)(coef * adj[y][x]);
		}
	}

	return 0;
}

int test_inverse_matrix()
{
	std::vector<float> vec{ 5, -2, 2, 7, 1, 0, 0, 3, -3, 1, 5, 0, 3, -1, -9, 4 };
	const int N{ 4 };
	if (vec.size() != (int)pow(N, 2)) {
		fprintf(stderr, "vec must be N^2\n");
		return -1;
	}

	std::vector<std::vector<float>> arr(N);
	for (int i = 0; i < N; ++i) {
		arr[i].resize(N);

		for (int j = 0; j < N; ++j) {
			arr[i][j] = vec[i * N + j];
		}
	}

	std::vector<std::vector<float>> inv1;
	int ret = inverse<float>(arr, inv1, N);

	fprintf(stderr, "source matrix: \n");
	print_matrix<float>(arr);
	fprintf(stderr, "c++ inverse matrix: \n");
	print_matrix<float>(inv1);

	cv::Mat mat(N, N, CV_32FC1, vec.data());
	cv::Mat inv2 = mat.inv();
	fprintf(stderr, "opencv inverse matrix: \n");
	print_matrix(inv2);

	return 0;
}
执行结果如下：

以下是用Eigen实现的矩阵求逆：

#include "funset.hpp"
#include <math.h>
#include <iostream>
#include <vector>
#include <string>
#include <opencv2/opencv.hpp>
#include <Eigen/Dense>
#include "common.hpp"

template<typename _Tp>
void print_matrix(const _Tp* data, const int rows, const int cols)
{
	for (int y = 0; y < rows; ++y) {
		for (int x = 0; x < cols; ++x) {
			fprintf(stderr, "  %f  ", static_cast<float>(data[y * cols + x]));
		}
		fprintf(stderr, "\n");
	}
	fprintf(stderr, "\n");
}

int test_inverse_matrix()
{
	std::vector<float> vec{ 5, -2, 2, 7, 1, 0, 0, 3, -3, 1, 5, 0, 3, -1, -9, 4 };
	const int N{ 4 };
	if (vec.size() != (int)pow(N, 2)) {
		fprintf(stderr, "vec must be N^2\n");
		return -1;
	}

	Eigen::Map<Eigen::MatrixXf> map(vec.data(), 4, 4);
	Eigen::MatrixXf inv = map.inverse();

	fprintf(stderr, "source matrix:\n");
	print_matrix<float>(vec.data(), N, N);
	fprintf(stderr, "eigen inverse matrix:\n");
	print_matrix<float>(inv.data(), N, N);

	return 0;
}
执行结果如下：


可见，三种实现方法结果是一致的。

GitHub：

https://github.com/fengbingchun/NN_Test

https://github.com/fengbingchun/Eigen_Test

fengbingchun
关注
  • 6
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
eigen 矩阵求逆_使用 Eigen 3.3.3 进行矩阵运算
weixin_42302418的博客
12-23 3807
Eigen是一个能够进行线性代数运算的C++开源软件包，包含矩阵和矢量操作，Matlab中对矩阵的大多数操作都可以在Eigen中找到。最近需要计算厄米特矩阵的逆，基于LLT分解和LDLT分解，自己写了几个代码，但精度不是很高，所以考虑了使用Eigen，精度和准确性还是蛮高的。网址:http://eigen.tuxfamily.org/index.php?title=Main_Page1. 如何在...
Eigen不同的方法来求矩阵的逆的效率
逐日者
05-27 4387
https://stackoverflow.com/questions/50909385/eigen-linear-solver-for-very-small-square-matrix 矩阵的逆的问题，一般类似求解：Ax=b----------------->x = A-1b 这里给出stackoverflow的一个关于这个求解的的效率的讨论： 4x4矩阵的求逆测试讨论 1 测试的方法以及种类 I am using Eigen on a C++ program for solving linea
【线性代数 & C++】结合逆矩阵的克拉默法则
最新发布
分享测绘及相关领域的知识
04-24 992
【代码】【线性代数 & C++】结合逆矩阵的克拉默法则。
eigen库安装_C++学习笔记——6. Eigen入门（矩阵运算及几何模块）
weixin_39726873的博客
11-20 491
「本文介绍了C++中Eigen库的代数运算模块和几何模块，以程序实例演示了常见指令用法。」Eigen是一个高层次开源C ++库，有效支持线性代数、矩阵和矢量运算、数值分析及其相关算法。在SLAM或者VIO研究中，对Eigen库的使用可以说非常多，因此掌握该库是非常重要且基础的能力。下面的内容大量参考了高翔博士编著的《SLAM十四讲》中对空间刚体运动部分的讲解，在此也强烈推荐一波这本书，语言很亲近，...
Eigen库-eigen代数运算(逆，特征值等)
明夷TEC的博客
06-09 8722
1 Eigen数据类型 Eigen是一个模板类，基本数据单元为矩阵，它的前3个参数为：数据类型，行，列，如下所示： Eigen::Matrix<float,2,3> matrix_23; Eigen通过tyepdef定义了许多内置类型，不过底层仍然是Eigen::Matrix,如下所示： Eigen::Matrix3d matrix_33 = Eigen::Matrix3d::Zero...
【OpenCV4】计算对称矩阵特征值和特征向量 cv::eigen() 用法详解和代码示例（c++）
AItrust的博客
08-16 2956
【OpenCV4】计算对称矩阵特征值和特征向量 cv::eigen() 用法详解和代码示例（c++）
基于C++的双目立体视觉三维重建设计与实现
05-04
在C++环境中实现这些步骤时，可以利用OpenCV库来处理图像和特征匹配，用Eigen库进行矩阵运算，用PCL库进行点云处理。同时，为了提高效率和准确性，可以采用多线程编程，如使用C++11以上的标准库中的std::thread。 ...
eigen 矩阵运算库文档手册
02-13
Eigen 可以与其他 C++ 库无缝集成，如 OpenCV、Blas、Lapack 等。此外，Eigen 支持多线程计算，可以利用 OpenMP 实现并行化。 ### 8. 文档与示例 `eigen-doc` 压缩包中包含了 Eigen 的详细文档，涵盖了所有的类、...
Gaborlvboqi-.rar_波变换_C/C++_
08-11
在实现Gabor小波变换时，可能需要利用线性代数库（如OpenCV或Eigen）进行矩阵运算，以及优化技巧来提高计算速度。 5. **程序结构**：一个典型的Gabor小波变换程序可能包含以下部分：预处理（如图像归一化）、生成...
solvecpp.rar_图形图象_C/C++_
08-11
在C/C++中，我们可以使用如`numpy`（通过`SWIG`或`Pybind11`等工具与C++交互）或直接使用线性代数库如`Eigen`来实现多项式拟合。对于低维度的数据，也可以手动实现矩阵运算，这通常涉及到求解系统的一组线性方程。 ...
Eigen 3 库文件及 unsupported 文件
11-15
在TensorFlow中，Eigen用于实现核心的张量操作，包括矩阵乘法、求逆、特征值分解等。由于嵌入式设备往往资源有限，将TensorFlow与Eigen结合使用能够优化计算效率，使模型能够在这些平台上运行。 在进行嵌入式移植时...
OpenCV与Eigen （C++）【学习备忘】
expert_joe的博客
01-17 4318
C++ OpenCV
OpenCV中的数值计算功能（一）矩阵求逆（伪逆）
可微函树的计算机视觉博客
07-23 1万+
OpenCV中的数值计算功能 ——矩阵求逆（伪逆）
Eigen库 矩阵基本操作：转置矩阵，逆矩阵，伴随矩阵，特征值
热门推荐
hankerbit的博客
09-03 4万+
#include &lt;iostream&gt; #include "Eigen\Dense" using namespace Eigen; using namespace std; int main() {     Matrix3d Mat1;     Mat1 &lt;&lt; 1, 2, 3,         4, 6, 8,         7, 9, 9;     cout &lt;&...
C++ 矩阵求逆(Eigen&DIY)-圆柱拟合
CoomCon的博客
03-29 1916
本文涵盖内容： 基于最小二乘法的空间任意方向的圆柱拟合， 以及矩阵求广义逆小知识，分为两个方法实现，一个是Eigen库和自编算法。 最小二乘拟合为发散型题。实现方法千千万，矩阵求逆只是其中一个方法。 20200329主要介绍，Eigen库矩阵求广义逆方法，后续内容慢慢更新 文章目录1.Eigen库基础知识2.Eigen求逆算法3.普通数据与Eigen数据交换 1.Eigen库基础知识 https:...
eigen 矩阵求逆_C++学习笔记——6. Eigen入门（矩阵运算及几何模块）
weixin_32375895的博客
01-26 2322
「本文介绍了C++中Eigen库的代数运算模块和几何模块，以程序实例演示了常见指令用法。」Eigen是一个高层次开源C ++库，有效支持线性代数、矩阵和矢量运算、数值分析及其相关算法。在SLAM或者VIO研究中，对Eigen库的使用可以说非常多，因此掌握该库是非常重要且基础的能力。下面的内容大量参考了0. Linux系统安装Eigen库在终端输入：sudo apt-get install lib...
eigen 矩阵求逆_Eigen矩阵的定义和基本运算
weixin_32464651的博客
12-23 1395
矩阵的定义#include #include // 稠密矩阵的代数运算(逆，特征值等)#include int main(){// 声明一个2*3的float矩阵Eigen::Matrix matrix_23;// 例如 Vector3d 实质上是 Eigen::Matrix，即三维向量Eigen::Vector3d v_3d;// Matrix3d 实质上是 Eigen::MatrixEigen...
线性代数代码实现（五）求矩阵的逆（C++）
qq_54434938的博客
10-21 1万+
前言： 在最近发布的两篇文章中，我们讲了两种判断矩阵是否可逆的方法，我们提到了矩阵的逆，那么很自然的就能想到，如何求解矩阵的逆，这篇文章中将会给出答案！ 一、线性代数知识回顾： 1. 如果矩阵可逆，那么矩阵的逆是唯一的 这个简单的定理我们给出证明：（一些证明起来比较麻烦的定理我们一般不给出证明） 若 n 阶矩阵可逆，记的一个逆为，另一个逆为，则： 由此可见，的逆唯一，因此我们可以记为 2. n 阶矩阵 可逆的充要条件是 可表示成一系列初等矩...
Eigen库常用的矩阵操作(持续更新)
qq_34508123的博客
10-13 1267
【代码】Eigen库常用的矩阵操作(持续更新)
C++与opencv实现手眼标定
05-17
手眼标定是指将机械臂的末端执行器与相机之间的相对姿态关系确定下来，这样可以用机械臂控制相机来实现精确的视觉引导。在手眼标定中，需要使用到相机的内外参数，机械臂的关节角度和末端执行器的位姿。下面介绍一种用C++实现手眼标定的方法。 1. 准备数据 首先需要获取机械臂的关节角度和末端执行器的位姿，以及相机的内外参数。可以通过机械臂的编程接口获取机械臂的状态信息，也可以手动记录机械臂运动时的关节角度和末端执行器位姿。相机的内外参数可以通过相机标定软件获取，例如OpenCV中的Camera Calibration。 2. 实现标定算法 手眼标定通常使用四元数来表示姿态关系，因为四元数可以避免万向锁问题。手眼标定的过程可以分为两步：计算机械臂的姿态变换矩阵和相机的姿态变换矩阵，然后通过求解手眼标定问题得到机械臂与相机的相对姿态矩阵。 计算机械臂的姿态变换矩阵可以通过机械臂的正运动学求解，计算相机的姿态变换矩阵可以通过相机的位姿信息求解，例如通过相机标定得到的旋转矩阵和平移矩阵。 通过求解手眼标定问题，可以得到机械臂与相机之间的相对姿态矩阵。手眼标定问题通常使用最小二乘法求解，可以使用OpenCV中的solvePnP函数求解。 3. 实现代码 下面是一个用C++和OpenCV实现手眼标定的代码示例： ``` #include <opencv2/opencv.hpp> #include <opencv2/core/eigen.hpp> #include <Eigen/Dense> using namespace cv; void handEyeCalibration(const std::vector<Mat>& robotPoses, const std::vector<Mat>& cameraPoses, Mat& H) { int n = robotPoses.size(); Mat A = Mat::zeros(n * 6, 6, CV_64F); Mat B = Mat::zeros(n * 6, 1, CV_64F); for (int i = 0; i < n - 1; i++) { Mat Ri1, ti1, Ri2, ti2; cv::Matx33d R1(cameraPoses[i](cv::Rect(0, 0, 3, 3))), R2(cameraPoses[i + 1](cv::Rect(0, 0, 3, 3))); cv::Vec3d t1(cameraPoses[i](cv::Rect(3, 0, 1, 3))), t2(cameraPoses[i + 1](cv::Rect(3, 0, 1, 3))); cv::Rodrigues(R1, Ri1); cv::Rodrigues(R2, Ri2); cv::Matx33d Ri = R2 * R1.t(); cv::Vec3d ti = t2 - R2 * t1; cv::Matx33d Ti(robotPoses[i](cv::Rect(0, 0, 3, 3))), Hi(robotPoses[i + 1](cv::Rect(0, 0, 3, 3))); cv::Vec3d pi(robotPoses[i](cv::Rect(3, 0, 1, 3))), hi(robotPoses[i + 1](cv::Rect(3, 0, 1, 3))); cv::Matx33d HiTi = Hi * Ti.t(); cv::Vec3d hi_ti = hi - Hi * ti; cv::Matx33d A1 = Ri.t() - cv::Matx33d::eye(); cv::Matx33d A2 = HiTi - cv::Matx33d::eye(); cv::Matx33d A3 = Hi * Ti.t() - Ri.t() * Hi; cv::Matx33d A4 = Hi * Ti.t() - cv::Matx33d::eye(); cv::Vec3d b1 = hi_ti; cv::Vec3d b2 = Hi * pi - pi * Ri.t(); cv::Vec3d b3 = Hi * ti - ti * Ri.t(); Mat Ai, Bi; cv::vconcat(Mat(A1), Mat(A2), Ai); cv::vconcat(Ai, Mat(A3), Ai); cv::vconcat(Ai, Mat(A4), Ai); cv::vconcat(Mat(b1), Mat(b2), Bi); cv::vconcat(Bi, Mat(b3), Bi); int idx = i * 6; Ai.copyTo(A.rowRange(idx, idx + 6)); Bi.copyTo(B.rowRange(idx, idx + 6)); } Mat X; solve(A, B, X, DECOMP_SVD); H = Mat::eye(4, 4, CV_64F); X.rowRange(0, 3).col(0).copyTo(H.rowRange(0, 3).col(0)); X.rowRange(3, 6).col(0).copyTo(H.rowRange(0, 3).col(1)); X.rowRange(6, 9).col(0).copyTo(H.rowRange(0, 3).col(2)); X.rowRange(9, 12).col(0).copyTo(H.rowRange(0, 3).col(3)); } int main() { std::vector<Mat> robotPoses; // 机械臂位姿 std::vector<Mat> cameraPoses; // 相机位姿 // 加载机械臂位姿和相机位姿 Mat H; handEyeCalibration(robotPoses, cameraPoses, H); std::cout << "Hand-eye calibration result: " << std::endl << H << std::endl; return 0; } ``` 其中，robotPoses和cameraPoses分别是机械臂和相机的位姿序列，H是求解得到的机械臂与相机之间的相对姿态矩阵。通过solve函数求解线性方程组得到H，然后将H转换为4x4的变换矩阵即可。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值