程序员经验分享-hwhale

eigen与opencv矩阵转换，eigen与matlab函数比照

2023-11-18

近期，项目需要，学习使用eigen矩阵库，链接时eigen的主页，发现相关中文资料比较少，今天写下使用心得~

eigen配置（windows vs系列）：

eigen的配置很简单，下载解压后，在VC++目录下的包含目录中，将eigen的路径包含进去，就可以使用了。

eigen的简单使用说明及实例：

  • Eigen中的所有密集矩阵和向量都是通过Matrix类来表示的。Matrix通过一系列的模板参数来生成具体的类别。
  • Matrix<Scalar, RowsAtCompileTime,ColsAtCompileTime>中，Scalar表示数据类型，RowsAtCompileTime和ColsAtCompileTime分别表示编译时的行数和列数。
  • Vector3d 定义为 Matrix<double,3,1>
  • 对于动态大小的类型，在编译时不指定行数和列数，使用Eigen::Dynamic。比如，VectorXd定义为Matrix<double, Dynamic,1>。

eigen的数据结构类型主要有：Matrix，Vector;其中大小又分为固定和动态两类，初始化方法如下：

Matrix<double, 3, 3> A;               // 固定大小的双精度矩阵，double,float,int为数据类型，也可表示为Matrix3d。  
Matrix<double, 3, Dynamic> B;         // 固定行数，列数为动态 
Matrix<double, Dynamic, Dynamic> C;   // 行数和列数都是动态大小，和MatrixXd一样  
Matrix<double, 3, 3, RowMajor> E;     // 行优先的矩阵（默认是列优先）  
Matrix3f P, Q, R;                     // 3x3 的浮点型矩阵  
Vector3f x, y, z;                     // 3x1 的浮点型矩阵（列向量）  
RowVector3f a, b, c;                  // 1x3 的浮点型矩阵（行向量）  
VectorXd v;                           // 动态大小的双精度列向量
上面，Xd中X表示动态大小，#include <Eigen/Dense>包含所有普通矩阵函数，不包括稀疏矩阵函数。A赋值时可以是： 
A<<1，2，5，
   3，5，6.0，
   5.5，6，7;

矩阵元素的访问：Eigen中矩阵、数组、向量的下标都是从0开始。矩阵元素的访问可以通过”()”操作符完成。例如m(2, 3)既是获取矩阵m的第2行第3列元素。

向量还可以使用”[]”操作符，注意矩阵不可用。实例1：

#include <Eigen/Dense>
#include <iostream>

using namespace std;
using namespace Eigen;

void main()
{
	MatrixXd m(2, 2);
	m(0, 0) = 3;
	m(1, 0) = 2.5;
	m(0, 1) = -1;
	m(1, 1) = m(1, 0) + m(0, 1);
	std::cout << "Here is the matrix m:\n" << m << std::endl;
	VectorXd v(2);
	v(0) = 4;
	v(1) = v(0) - 1;
	std::cout << "Here is the vector v:\n" << v << std::endl;
	return;
}

Resizing

矩阵的大小查询方法有： rows(), cols() and size()，分别表示矩阵的行数、列数和元素总数。可以通过 resize()方法改变动态矩阵的大小。

注意：(1)、固定大小的矩阵是不能使用resize()来修改矩阵的大小；(2)、resize()函数会析构掉原来的数据，因此调用resize()函数之后将不能保证元素的值不改变；(3)、使用”=”操作符操作动态矩阵时，如果左右两边的矩阵大小不等，则左边的动态矩阵的大小会被修改为右边的大小。

实例2： 

#include <iostream>
#include <Eigen/Dense>
using namespace Eigen;
int main()
{
  MatrixXd m(2,5);
  m.resize(4,3);
  std::cout << "The matrix m is of size "
            << m.rows() << "x" << m.cols() << std::endl;
  std::cout << "It has " << m.size() << " coefficients" << std::endl;
  VectorXd v(2);
  v.resize(5);
  std::cout << "The vector v is of size " << v.size() << std::endl;
  std::cout << "As a matrix, v is of size "
            << v.rows() << "x" << v.cols() << std::endl;
}

总结：

Eigen defines the following Matrix typedefs:

  • MatrixNt for Matrix<type, N, N>. For example, MatrixXi for Matrix<int, Dynamic, Dynamic>.
  • VectorNt for Matrix<type, N, 1>. For example, Vector2f for Matrix<float, 2, 1>.
  • RowVectorNt for Matrix<type, 1, N>. For example, RowVector3d for Matrix<double, 1, 3>.

Where:

  • N can be any one of 2, 3, 4, or X (meaning Dynamic).
  • type can be any one of i (meaning int), f (meaning float), d (meaning double), cf (meaning complex<float>), or cd(meaning complex<double>). The fact that typedefs are only defined for these five types doesn't mean that they are the only supported scalar types. For example, all standard integer types are supported, see Scalar types.

opencv与eigen的交互

opencv矩阵结构为：cv::Mat，或者cv::Mat_<type>等，当需要与eigen的矩阵结构相互转换时主要使用函数：
cv::eigen2cv和cv::cv2eigen,需要头文件：#include<opencv2/core/eigen.hpp>
实例3： 
#include <Eigen/Dense>
#include <iostream>
#include <opencv2/core/eigen.hpp>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;
using namespace Eigen;

void main()
{
	Mat img = imread("jasen.jpg",CV_LOAD_IMAGE_GRAYSCALE);
	int row = img.rows;
	int col = img.cols;
	MatrixXd m(row, col);
	cv2eigen(img,m);
	return;
}
实例4： 
#include <Eigen/Dense>
#include <iostream>
#include <opencv2/core/eigen.hpp>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;
using namespace Eigen;

void main()
{
	Mat img;
	Matrix<int,100,100> m ;
	m.fill(255);
	eigen2cv(m, img);
	return;
}

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的元素上 (当编译时不知道大小时，可选语法)

参考：

http://eigen.tuxfamily.org/dox/group__TutorialMatrixClass.html

http://blog.csdn.net/xuezhisdc/article/details/54645238
http://eigen.tuxfamily.org/dox/group__TutorialMatrixArithmetic.html
http://blog.csdn.net/column/details/14470.html
https://www.cnblogs.com/goudanli/p/8259590.html

https://stackoverflow.com/questions/32605838/error-eigen-library-on-linux




本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

CC

eigen opencv

eigen与opencv矩阵转换，eigen与matlab函数比照 的相关文章

  • 九龙战登录只显示一个服务器,九龙战登录失败进不去解决办法

    九龙战是腾讯推出的一款三国题材的动作竞技手游 目前已经开启了不删档测试 但是玩家们在游戏中遇到了登录失败进不去的情况 下面小编就为大家介绍一下九龙战登录失败进不去解决办法 首先玩家们要知道九龙战是一款不删档测试不久的游戏 所以在这期间出现什

随机推荐

  • Android基于BroadcastReceiver和Service、SoundPool开发的防过充助手app

    前段时间换了一个小米4C手机 可是发现它的充电充满没有提醒 上一个手机换了就是因为不爱惜电池 让它过充的次数多了 虽然听别人说小米4c手机充电器是智能充电器 有保护作用 但我自己还是不放心 于是就亲手写了一个防过充小应用 已经在使用 可以达

  • 如何使用LaTeX制作PPT？

    作为LaTeX排版软件 LaTeX主要被用来制作书籍和文章 但由于现代LaTeX系统主要以PDF文件为输出方式 授课 演讲用的计算机幻灯片也日益成为LaTeX的一个重要应用 LaTeX中专门用来制作幻灯片的工具有powerdot文档类 pr

  • 探索.NET：​构建现代软件开发的核心框架

    摘要 在现代软件开发领域 选择一个合适的开发框架对于成功构建可靠 高效的应用程序至关重要 NET 读作 dot net 是一个强大而广泛使用的框架 为开发人员提供了丰富的工具和功能 以简化开发过程并加快交付时间 本文将介绍 NET的基本概念

  • 【手撕RPC服务分几步】

    手撕RPC服务分几步 前言 什么是RPC 从被调用方 provider 来说 从调用方 consumer 来说 扩展思考 dubbo架构图 前言 本文试图通过手撕RPC的理论步骤来帮助我们更好的理解其特性 也更好的理解像Dubbo sofa

  • flutter 填坑之旅（dart学习笔记篇）

    俗话说 工欲善其事必先利其器 想要撸flutter app 而不懂 dart 那就像一个不会英语的人在和英国人交流 懵 安装 dart 就不用说了 比较简单dart 官网 https dart dev 安装完成后就开启学习dart 旅程吧

  • MyEclipse配置Tomcat7

    首先我们打开Myeclipse 进入偏好设置window gt perferences 进入偏好设置 perferences 在偏好设置的搜索栏那里输入tomcat查找tomcat 如下图所示 3 我们可以看到搜索到的有四个tomcat项

  • (笔试前准备)字符串匹配算法总结

    我想说一句 我日 我讨厌KMP KMP虽然经典 但是理解起来极其复杂 好不容易理解好了 便起码来巨麻烦 老子就是今天图书馆在写了几个小时才勉强写了一个有bug的 效率不高的KMP 特别是计算next数组的部分 其实 比KMP算法速度快的算法

  • STM32 HAL库更改中断向量表的偏移地址

    以STM32F767为例 打开system stm32f7xx c文件 定位VECT TAB OFFSET 更改此宏定义的值 即可更改偏移量

  • 富维火焰识别算法

    火灾是威胁公共安全 危害人民生命财产的灾害之一 加强消防安全管理是头等大事 对火灾做到早预防 早发现 尽量避免火灾的发生尤为重要 近年来随着网络摄像机的广泛使用以及图像处理技术的不断发展 基于视频的北京富维图像火焰识别算法得到了越来越多的关

  • Android Rom修改制作工具软件集合

    2019独角兽企业重金招聘Python工程师标准 gt gt gt 1 SIN2IMG 用于固件ftf中system sin的解包 下载地址 SIN2IMG rar 使用方法 将固件ftf文件用rar打开 解压出system sin文件 将

  • Idea 修改默认的Maven配置及修改为阿里源

    每次使用Idea创建或者导入Maven项目的时候 Idea都会使用系统默认的Maven 此时 如果我们想使用自定义安装的Maven 需要在File gt other settings gt Settings for New Projects

  • STM32-custom usb

    如何建立一个自定义的HID工程呢 下面就来讲讲 首先先介绍下工程的架构 工程的总体架构下图所示 按照下图架构建工程 分析下工程布局 首先是APP 这个组里存放着主文件mian c 管理所有中断服务程序stm3210x it c 及其管理外设

  • PageObjects支持库-Poium使用方法

    PO模式 学过自动化的都知道PageObjects模式 将页面对象封装为类 页面元素和操作封装为类的属性和方法 在测试方法中调用页面对象进行测试 关于PO模式可见 http t csdn cn 0DBlP 在PO模式下 我们一般定义个一个基

  • 想写一本书，而这是序言

    口袋书 序言 现在的风口是什么 很多人会答人工智能 Artificial Intelligence AI 人工智能是一项伟大的发明 我们不得不承认 它已经为社会带来了翻天覆地的变化 并 将在未来卷起更大的风暴 不了解人工智能 就难以在这个

  • 前端js将扁平化数据转化为=菜单树

    let menuList id 1 pid 1 name 江西 id 2 pid 1 name 南昌 id 3 pid 1 name 九江 id 4 pid 1 name 广东 id 5 pid 4 n

  • 【考研】数据结构——线索二叉树

    CSDN话题挑战赛第2期 参赛话题 学习笔记 前言 本文内容源于对 数据结构 C语言版 第2版 王道讲解学习所得心得 笔记整理和总结 本文针对线索二叉树 在最后的练习中 以举例子说明该排序方法 配以图文 讲解详细 含408真题 可搭配以下链

  • 学校与工作(献于在校大学生及入职不久的工作者）

    学校与工作 每个人都把自己眼界的局限当成世界的局限 学校是非常不同于职业工作的 有些人在其早期职业生涯中栽跟头 就是因为未能从已经生活了近20年的学校环境过渡到软件行业的美丽新世界 学生的活动具有高度约束性 工作量都是规定好了的 虽然当你是

  • IEEE-754标准浮点数,十六进制与十进制转换方法（附C代码）

    十进制数与IEEE 754 32 位转换实例讲解 https blog csdn net qq 41629142 article details 83692106 https blog csdn net a627088424 article

  • springboot集成kafka实战项目，kafka生产者、消费者、创建topic，指定消费分区

    springboot集成kafka实战项目 kafka生产者 消费者 创建topic 指定消费分区 前言 本项目代码可直接集成到你现有的springboot项目中 功能包括 1 kafka生产者配置 2 kafka消费者配置 指定分区消费

  • eigen与opencv矩阵转换，eigen与matlab函数比照

    近期 项目需要 学习使用eigen矩阵库 链接时eigen的主页 发现相关中文资料比较少 今天写下使用心得 eigen配置 windows vs系列 eigen的配置很简单 下载解压后 在VC 目录下的包含目录中 将eigen的路径包含进去

热门标签