精华内容
下载资源
问答
  • opencv矩阵与eigen矩阵的转换

    千次阅读 2019-08-17 09:29:30
    opencv矩阵结构:cv::Mat,或者cv::Mat_等,当需要与eigen的矩阵结构相互转换时主要使用函数: cv::eigen2cv和cv::cv2eigen,需要头文件:#include<opencv2/core/eigen.hpp> 实例: #include <Eigen/Dense...

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

    #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;
    }
    

    实例:

    #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;
    }
    
    展开全文
  • OpenCV中xml矩阵转换为MATLAB的矩阵,里面有demo-xml文件,注意一定要改为适合自己使用的。
  • 近期,项目需要,学习使用eigen矩阵库,链接时eigen的主页,发现相关中文资料比较少,今天写下使用心得~ eigen配置(windows vs系列): eigen的配置很简单,下载解压后,在VC++目录下的包含目录中,将eigen的路径...

    近期,项目需要,学习使用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 234, 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




    展开全文
  • opencv 矩阵数据类型及转换方式 在完成多个连续图像取色彩平均值时出现了处理后的图像色彩偏暗的情况(使用...opencv矩阵数据类型及其取值范围: 数据类型中C1、C2、C3、C4图像的通道数,如CV_8UC1八位无符号...

    opencv 矩阵数据类型及转换方式

    在完成多个连续图像取色彩平均值时出现了处理后的图像色彩偏暗的情况(使用(pic1+pic2+…+picn)/n的方式求多个图像平均值),经过查找资料发现原因:
    图像的矩阵数据类型8位的最大值只有255,多个图像相加后色彩最大值依旧为255,取平均时导致数值变小,故图像整体偏暗。
    进行图像相加的时候所有图片需变成32位可解决此问题。

    opencv矩阵数据类型及其取值范围:

    在这里插入图片描述
    数据类型中C1、C2、C3、C4为图像的通道数,如CV_8UC1为八位无符号数存储的单通道图像。

    opencv矩阵数据类型转换方式:

    使用convertTo(dst, type, scale, shift)函数:
    dst:目的矩阵;
    type:需要的输出矩阵类型,或者更明确的,是输出矩阵的深度,如果是负值(常用-1)则输出矩阵和输入矩阵类型相同;
    scale:比例因子;
    shift:将输入数组元素按比例缩放后添加的值;
    如果scale=1,shift=0,则不进行比例缩放。
    转化的实例代码如下:

    Mat pic1(rows,cols,CV_32FC1); 
    Mat pic2;  
    pic2.convertTo(pic1,CV_32FC1,1,0);
    
    展开全文
  • 文章目录图片转化成矩阵方法一:方法二:矩阵转换图片错误代码段正确代码段 图片转化成矩阵 方法一: 使用 PIL 的方法 + img.getdata() 提取数据 + np.array() 的转换 最后得到的结果是个二维数组 from PIL ...

    图片转化成矩阵

    方法一:

    使用 PIL 的方法 + img.getdata() 提取数据 + np.array() 的转换

    • 最后得到的结果是个二维数组
    from PIL import Image
    import numpy as np
    '''图片转数组'''
    img = Image.open('1.jpg')   # 使用 PIL 打开图片
    data = img.getdata()   # 获取图片的数据信息 class <'ImagingCore'>
    data = np.array(data)   # 把这个数据通过 numpy 转换成多维度的张量
    print(data)
    

    在这里插入图片描述

    方法二:

    直接用 cv2.imread() 读出来就是个三维的数组

    import cv2
    img2 = cv2.imread('1.jpg')  # 使用 cv2 来打开图片
    print(img2)
    

    在这里插入图片描述
    如果想知道方法一和方法二的区别,可以查阅我的上一篇 opencv 学习文章:
    https://blog.csdn.net/qq_42902997/article/details/108326214

    矩阵转换成图片

    • 产生一个 625 * 625 * 3 的图片,先产生 625 * 625 * 3 = 1171875 个像素点
    • 将产生的数据通过numpy 进行 resize
    • 将处理过的矩阵通过 imwrite 写成新的图片(如果没有这一步而直接 imshow 会出错)

    错误代码段

    data = [random.randint(0,255) for _ in range(1171875)]
    data = np.resize(data,(625,625,3))
    print(data)
    
    cv2.imshow('img2',data)  # 错误示范:这里直接将矩阵是 imshow 不出结果的
    cv2.waitKey(0)
    

    正确代码段

    import numpy as np
    import cv2
    import random
    
    data = [random.randint(0,255) for _ in range(1171875)]   
    data = np.resize(data,(625,625,3))
    print(data)
    cv2.imwrite('2.jpg',data)
    s = cv2.imread('2.jpg')
    cv2.imshow('img2',s)
    cv2.waitKey(0)
    

    最后产生了一张这样的图:其中像素点的值都在 0-255 之间
    在这里插入图片描述

    展开全文
  • Eigen与Opencv之间的转换,在包含Eigen库的基础上,#include<opencv2/core/eigen.hpp> ...将Eigen::Matrix转换为cv::Mat cv::eigen2cv(matrix,mat); #include <Eigen/Dense> #in...
  • OpenCV矩阵类型Mat属于core模块,故需要opencv_core249.dll动态库。先写好需要编译的cpp文件,命名getMat.cpp,如下内容: #include "opencv2/opencv.hpp" #include #include "mex.h" void mexFunction(int nlhs, ...
  • OpenCV 矩阵 到 图像 转换

    千次阅读 2013-03-11 20:11:58
    【转载】OpenCV根据 数据矩阵 创建图像 原文出处:http://my.csdn.net/c4501srsy/code/detail/21397 C++ Code   data=newBYTE[300*200*3]; memset(data,128,300*200*3);// 准备颜色...
  • 矩阵和tensor相互转换 cvmat到tensor tips: 这里主要要注意的就是在opencv和pytorch中存储顺序的差异 cv::cvtColor(frame, frame, CV_BGR2RGB); //normalization frame.convertTo(frame, CV_32FC3, 1.0f / 255.0...
  • OpenCV矩阵数据类型转换
  • OpenCV矩阵操作

    千次阅读 2018-08-18 18:00:46
    除此之外,也有很多操作被表示“友元”函数,它们的输入为矩阵类型,或者输出为矩阵类型,或者输入输出同为矩阵类型。下面将对这些函数及其参数进行详细介绍。 目录 cv::abs()和cv::absdiff cv::add() cv::...
  • 使用Qt显示openCV矩阵图片

    万次阅读 多人点赞 2013-05-29 15:51:29
     使用的QtCreator,如果使用的其他编译器需要同事配置好Qt和openCV 2.首先使用Qt建立一个ui界面 绘制2个按钮和一个label 3.在头文件声明一个Mat类和一个QImage类 .处理添加两个按钮的sl
  • 函数用法转自这里在OpenCV中很多对数据的运算都需要转换为64F类型,比如伽玛变换,这个很明显要求幂的底数是double类型~ 而cvShowImage()又要求是U8才能显示,否则显示出来是一片空白! 所以经常要进行转换,怎么...
  • 1. 图片的读取和显示 #!/usr/bin/python # -*-coding:utf-8-*- """ @author: yugengde @contact: yugengde@163.com @file : image.py @time: 2018/2/9 13:38 """ import cv2import sys if __name__ =...
  • openCV矩阵操作

    万次阅读 2013-08-07 08:49:10
    OpenCv矩阵操作 有很多函数有mask,代表掩码,如果某位mask是0,那么对应的src的那一位就不计算,mask要和矩阵/ROI/的大小相等 大多数函数支持ROI,如果图像ROI被设置,那么只处理ROI部分 少部分函数支持COI,...
  • OpenCV矩阵运算总结

    万次阅读 2018-01-31 10:09:32
    篇一:OpenCV矩阵运算总结 原文地址:http://www.cvvision.cn/273.html 著作权归作者所有。 商业转载请联系作者获得授权,非商业转载请注明出处。 作者:cvvision 链接:http://www.cvvision.cn/273.html 来源:CV...
  • OpenCV把彩色图片转换为灰度图片

    万次阅读 2019-08-26 10:41:36
    在实现彩色图片转换为灰度图片之前,先来了解一下图像数字化。当你张开眼睛,就看到现实的世界,比如房子,花草和不同的物品。如果要把当前的眼睛所见的东西保存起来,在以前是使用胶片相机,那是采用化学的感光方法...
  • OpenCv矩阵操作

    千次阅读 2011-11-27 01:22:04
    OpenCv矩阵操作 有很多函数有mask,代表掩码,如果某位mask是0,那么对应的src的那一位就不计算,mask要和矩阵/ROI/的大小相等 大多数函数支持ROI,如果图像ROI被设置,那么只处理ROI部分 少部分函数支持COI,...
  • OpenCV 矩阵操作

    千次阅读 2010-11-09 20:18:00
    OpenCV 矩阵操作 加减乘除 求逆 行列式值 http://www.opencv.org.cn/index.php/Cxcore%E6%95%B0%E7%BB%84%E6%93%8D%E4%BD%9C#SolveGEMM<br />通用矩阵乘法void cvGEMM( const CvArr* src1, const ...
  • image = Image.fromarray(data) #将之前的矩阵转换为图片 image.show() #调用本地软件显示图片,win10是叫照片的工具 readData() 截图控制栏: 截图照片显示: ok,大功告成,是不是很简单啊 ...
  •   opencv 矩阵的相似性对比 (图片之间比较) 2013-08-17 14:18 1558人阅读 评论(0) 收藏 举报  分类:   openCV
  • opencv中的warpAffine以图像原点旋转,而pytorch中的F.affine_grid图片中心旋转,此外warpAffine的平移变换以像素单位进行,而F.affine_grid以宽高的比率进行平移变换,需要对其变换矩阵进行一个转换。...
  • OpenCV矩阵数据类型转换cv::convertTo

    万次阅读 2015-10-17 14:58:59
    矩阵数据类型转换函数convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) 的使用方法及示例
  • OpenCV矩阵函数操作大全

    千次阅读 2012-07-10 15:17:49
    OpenCv矩阵操作   有很多函数有mask,代表掩码,如果某位mask是,那么对应的src的那一位就不计算,mask要和矩阵/ROI/的大小相等   大多数函数支持ROI,如果图像ROI被设置,那么只处理ROI部分
  • OpenCV—基本矩阵操作与示例

    万次阅读 多人点赞 2016-05-02 16:30:14
    图像处理中对矩阵的操作非常重要,本文总结了使用OpenCV进行矩阵的创建、初始化以及基本矩阵操作,给出了示例代码。
  • OPENCV 矩阵操作

    千次阅读 2011-08-19 13:30:46
    最近使用opencv+vs2008读取摄像头的时候,抓取图像总是返回空。无解,在网上看到一个资料,转载于此。 GEMM 通用矩阵乘法 void cvGEMM( const CvArr* src1, const CvArr* src2, double alpha, const
  • OpenCV矩阵运算

    万次阅读 2013-03-02 21:42:03
    一、矩阵 Mat I,img,I1,I2,dst,A,B; double k,alpha; Scalar s; 1.加法 I=I1+I2;//等同add(I1,I2,I); add(I1,I2,dst,mask,dtype); scaleAdd(I1,scale,I2,dst);//dst=scale*I1+I2; 2.减法 absdiff(I1,I2,I);...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,593
精华内容 8,637
关键字:

opencv矩阵转换为图片