精华内容
下载资源
问答
  • OpenCV中构造Mat矩阵赋值和复制的…

    千次阅读 2017-06-29 10:20:28
    对OpenCV中的Mat矩阵复制,创建等操作的时间消耗 代码如下: clock_t t1,t2; t1 = clock(); Mat mat1(10000,5000,CV_64FC1,Scalar::all(0.0)); t2 = clock(); cout<<"Mat mat1(10000,5000,CV_64FC1,Scalar::all...

    对OpenCV中的Mat矩阵的复制,创建等操作的时间消耗
    代码如下:
    clock_t t1,t2;
    t1 = clock();
    Mat mat1(10000,5000,CV_64FC1,Scalar::all(0.0));
    t2 = clock();
    cout<<"Matmat1(10000,5000,CV_64FC1,Scalar::all(0.0))\t"<<t2-t1<<endl;
     
    {
    t1 = clock();
    Mat mat2(mat1);
    t2 = clock();
    cout<<"Mat mat2(mat1)\t"<<t2-t1<<endl;
    }
     
    {
    Mat mat3(500,500,CV_64FC1,Scalar::all(0.0));
    t1 = clock();
    mat3 = mat1;
    t2 = clock();
    cout<<"mat3 = mat1;\t"<<t2-t1<<endl;
    }
     
    {
    Mat mat4;
    t1 = clock();
    mat1.copyTo(mat4);
    t2 = clock();
    cout<<"mat1.copyTo(mat4);\t"<<t2-t1<<endl;
    }
     
    {
    Mat mat4;
    t1 = clock();
    mat4 = mat1.clone();
    t2 = clock();
    cout<<"mat4 =mat1.clone();\t"<<t2-t1<<endl;
    }
     
    {
    Mat mat5(10000,5000,CV_32FC1,Scalar::all(0.0));
    t1 = clock();
    mat1.convertTo(mat5,CV_32FC1);
    t2 = clock();
    cout<<"mat1.convertTo(mat5,CV_32FC1);\t"<<t2-t1<<endl;
    }
    一个典型的输出。
    Mat mat1(10000,5000,CV_64FC1,Scalar::all(0.0)) 540
    Mat mat2(mat1)  0
    mat3 = mat1;   1
    mat1.copyTo(mat4);     515
    mat4 =mat1.clone();   465
    mat1.convertTo(mat5,CV_32FC1);  488
    另一个运行的输出。
    Mat mat1(10000,5000,CV_64FC1,Scalar::all(0.0)) 391
    Mat mat2(mat1)  0
    mat3 = mat1;   0
    mat1.copyTo(mat4);     433
    mat4 =mat1.clone();   453
    mat1.convertTo(mat5,CV_32FC1);  495
    从结果中可以看到,拷贝构造函数和赋值的时间可以忽略不计,但Mat::copyTo、Mat::clone、Mat::convertTo等需要申请空间或复制数据的操作就需要大量的时间。
    附:

    for (std::vector::iterator iter = vecSrcImg.begin(); iter !=vecSrcImg.end(); iter++)
    {

    t1 = (double)cvGetTickCount();

    Mat srcMat( srcImg.rows, srcImg.cols, CV_8UC(1), Scalar::all(0));
    //12ms
    Mat srcMat(srcMatTemp);
    //0.2ms

    srcMat = *iter;
    //10ms
    //Mat dstMat(srcImg.rows, srcImg.cols, CV_8UC(1),Scalar::all(0));//12ms
    Mat dstMat(srcMatTemp);//0.2ms

    Gassian_Histogram(srcMat, dstMat, 2.0);

    unsigned char* imgData = srcMat.data;
    Gassian_like_histogram(imgData, srcImg.cols, srcImg.rows, 2.0);

    tempT = (double)cvGetTickCount() - t1;

    printf( " histogramGaussian cost time = %gms\n",tempT/((double)cvGetTickFrequency()*1000.) );

      dstMat.data = imgData;

    vecDstImg.push_back(dstMat);

    }

    展开全文
  • Opencv Mat矩阵操作

    千次阅读 2019-05-28 22:21:47
    Opencv Mat矩阵操作 1.生成矩阵: Mat image(240, 320, CV8UC3); 第一个参数是rows,该矩阵的行数;第二个参数是cols,该矩阵的列数;第三个参数是该矩阵元素的类型。这句话表示创建一个大小为240×320的矩阵,里面...

    Opencv Mat矩阵操作

    1.生成矩阵:

    Mat image(240, 320, CV8UC3);
    

    第一个参数是rows,该矩阵的行数;第二个参数是cols,该矩阵的列数;第三个参数是该矩阵元素的类型。这句话表示创建一个大小为240×320的矩阵,里面的元素为8位unsigned型,通道数(channel)有3个。

    image.create(480, 640, CV8UC3);
    

    分配(或重新分配)image矩阵,把大小设为480×640,类型设为CV8UC3。

    Mat A33(3, 3,CV_32F, Scalar(5));
    

    定义并初始化一个3×3的32bit浮点数矩阵,每个元素都设为5。

    Mat B33(3, 3,CV_32F);
    B33 = Scalar(5);
    

    和上面的作用一样。

    Mat C33 =Mat::ones(3, 3, CV32F)*5.0;
    

    ones函数很像MATLAB里的语句。这句的意思是先定义一个3×3的32bit浮点数矩阵,元素全为1,所有元素再乘以5.0。

    Mat D33 =Mat::zeros(3, 3, CV32F) + 5.0;
    

    和上面类似,先定义个3×3的32bit浮点数矩阵,元素全为0,再将所有元素加上5.0;

    Mat D33 = Mat::eye(4,4,CV_64F);//对角矩阵
    double a = CV_PI/3;
    Mat A22 = (Mat_(2, 2) << cos(a), -sin(a), sin(a), cos(a));
    

    CV_PI就是圆周率。是创建一个2×2的float矩阵,把后面四个三角函数值分别赋给4个元素。

    float B22data[] ={cos(a), -sin(a), sin(a), cos(a)};
    Mat B22 = Mat(2, 2, CV32F, B22data).clone();
    

    第一句创建一个普通数组B22data,第二句创建一个2×2的32bit浮点数矩阵,并使用用B22data数组里的值初始化,然后克隆一下赋给B22矩阵。
    为什么这里还要克隆一下,不是多此一举吗?不是,因为用一个数组去初始化一个矩阵的话,你会发现这个矩阵引用了数组的内存地址。不克隆的话,上面例程的后果是B22data数组、Mat(2,2…)这个临时变量矩阵、B22矩阵这三把勺子都插在同一个碗里。

    randu(image,Scalar(0), Scalar(256));
    

    把image弄成一个符合正太分布的随机数矩阵,rand表示random,u表示uniform;第二个参数是随机数下限,包含该数;第三个参数是随机数上限,不包含该数。

    randn(image,Scalar(128), Scalar(10));
    

    高斯分布的随机数矩阵;第二个参数是均值,第三个参数是标差。

    矩阵输出:

    cout<< "M = " << endl << " " << M<< endl << endl;
    

    2. 赋值运算

    Mat A,C;    //仅创建了头部
    Mat B(A);    //复制构造函数
    C=A;    //复制运算
    

    **注:**赋值运算符和复制构造函数 (构造函数)只复制头,没有数据。

    src.copyTo(dst);    //把src矩阵中的数据拷贝到dst
    src.convertTo(dst, type, scale, shift);
    

    缩放并转换到另外一种数据类型:dst:目的矩阵 type:需要的输出矩阵类型,或者更明确的,是输出矩阵的深度,如果是负值(常用-1)则输出矩阵和输入矩阵类型相同 scale和shift:缩放参数,也可以写为alpha和beta这个命令也等价于下面的转换公式: m ( x , y ) = s a t u r a t e c a s t ( α ( ∗ t h i s ) ( x , y ) + β ) m(x,y) =saturatecast(α(*this)(x,y)+β) m(x,y)=saturatecast(α(this)(x,y)+β)

    m.row(i), m.col(i);
    

    创建一个矩阵头,指向m矩阵的第i行/列,新的矩阵头所代表的矩阵和m矩阵的第i行/列共享数据。

    m.rowRange(Range(i1,i2));
    m.colRange(Range(j1,j2));
    

    创建一个矩阵头,指向m矩阵的第i1到i2行或者第j1到j2列

    m.diag(i);
    

    创建一个矩阵头,指向m矩阵的对角线,生成的是一个单列矩阵,O(1)复杂度,不拷贝数据。i=0时表示主对角线,i>0表示下半边的对角线,i<0表示上半边的对角线。

    m(Range(i1,i2),Range(j1,j2));    //Range(i1,i2)包含i1不包含i2  行列编号从0开始
    

    从矩阵m中的第i1行到第i2行以及第j1列到第j2列所划定的范围提取一个小矩阵。

    m(Range::all(),Range(j1,j2));    //Range::all()表示所有行 [j1,j2]列
    
    m.repeat(ny,nx);
    

    把m矩阵贴马赛克,获取一个大矩阵,在y方向上重复ny次,在x方向上重复nx次。

    flip(src,dst,dir);
    

    翻转矩阵,dir是翻转方向,0表示沿x轴翻转,1表示沿y轴翻转,-1表示沿x轴和y轴都进行翻转。

    3、算术运算

    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);    //I=|I1-I2|;
    A-B;A-s;s-A;-A;
    subtract(I1,I2,dst);
    

    3.乘法

    I = I.mul(I);    //点乘,I.mul(I,3);-->I=3*I.^2
    Mat C=A.mul(5/B);    //==divide(A,B,C,5);
    A * B;    //矩阵相乘
    A.dot(B);    //A和B点乘,然后求所有元素和, 
    pow(src,double p,dst);    //如果p是整数dst(I)=src(I)^p;其他|src(I)|^p
    Mat::cross(Mat);    //三维向量(或矩阵)的叉乘,A.cross(B)
    

    4.除法

    divide(I1,I2,dst,scale,int dtype=-1);    //dst=saturate_cast(I1*scale/I2);
    A/B;  alpha/A;    //都是点除
    

    4、其他操作

    1.矩阵元素访问

    A.rows    //矩阵行数     
    A.cols    //矩阵列数
    A.row(i)    //取第i行  行编号从0开始
    A.col(j)    //取第i列  列编号从0开始
    A.at<type>(i,j)    //访问矩阵第(i,j)  注意矩阵A的类型,否则异常或取值出错 如:A为CV_32CF1时,type为int型时,所取值为异常值,不是矩阵值。
    

    2.矩阵变形:

    A.reshape(int cn, int rows);
    

    参数cn:新的通道数;如果cn值为0表示变换前后通道数不变
    参数rows:新的行数;如果rows值为0表示变换后矩阵的行数不变
    该函数会为当前矩阵创建一个新的矩阵头(指针),新的矩阵拥有不同的尺寸或者不同的通道数,其优点在于运算复杂度为O(1),不用复制矩阵数据.正是因为不用复制数据,所以在转变过程中要保证原数据矩阵在数据上的连续性(这里的连续性是相对于原矩阵来说)。

    注:A要为单独矩阵,不能直接为矩阵的一部分。

    3.转置运算:

    A.t()
    

    4.矩阵求逆:

    A.inv(type)
    

    Type: CV_LU - 最佳主元选取的高斯消除法
    CV_SVD - 奇异值分解法 (SVD)
    CV_SVD_SYM - 对正定对称矩阵的 SVD 方法

    5.SVD分解:

    SVD::compute(A,D,U,V,flag=0;
    

    Flag可以为空即:SVD::compute(A,D,U,V),D为列矩阵,元素为A的特征值,A=U*diag(D)*V ,diag(D)是把D变成对角阵,与matlab相比,U与matlab值相同,正负号不同,V为matlab中V的转置,正负号不同。

    6.最大最小值:

    不需的值可以设成0,如: minMaxLoc(A, 0, 0, 0, &max_loc); 求A中最大值的位置,max_loc定义为:Point max_loc max_loc.x为横坐标,对应图像的列,max_loc.y为纵坐标,对应图像的行。

    7.矩阵合并

    hconcat(A,B,dst1)   水平方向合并
    vconcat(A,B,dst2)   垂直方向合并
    

    A=[1 ,2; B=[5,6; dst1=[ 1 2 5 6;
      3 ,4 ]   7,8]    3 4 7 8 ]
    dst2=[1 2;
       3 4;
       5 6;
       7 8]

    8.矩阵底部添加、删除元素

    A.push_back(B);    //B添加在A的底部,B可以是常数
    A.pop_back(m);    //从A的底部删除m行
    

    注:添加时A,B的类型和行数必须相同,删除时,m不能大于A的行数,否则异常,另外,添加和删除后的矩阵,不能用于算术运算,否则异常。

    9.矩阵行列求和

    Reduce( inputArry src, outputArry, int dim, int rtype,int dtype=-1);
    

    dim :
    矩阵被简化后的维数索引.0意味着矩阵被处理成一行,1意味着矩阵被处理成为一列,-1时维数将根据输出向量的大小自动选择.
    rtype :
    简化操作的方式,可以有以下几种取值:
    CV_REDUCE_SUM-输出是矩阵的所有行/列的和.
    CV_REDUCE_AVG-输出是矩阵的所有行/列的平均向量.
    CV_REDUCE_MAX-输出是矩阵的所有行/列的最大值.
    CV_REDUCE_MIN-输出是矩阵的所有行/列的最小值.

    展开全文
  • 初识Mat矩阵

    2018-08-09 21:30:13
    Mat矩阵 参考link 什么是Mat矩阵 Mat矩阵是一个类,定义于core.cpp中 Mat举证包含两个部分 - 矩阵头(包含矩阵的大小,存储方式,矩阵存储地址) - 指向矩阵包含像素值的指针(data) &amp;lt;span ...

    Mat矩阵

    什么是Mat矩阵

    Mat矩阵是一个类,定义于core.cpp中
    Mat举证包含两个部分
    - 矩阵头(包含矩阵的大小,存储方式,矩阵存储地址)
    - 指向矩阵包含像素值的指针(data)

    <span style="font-size:12px;">class CV_EXPORTS Mat  
    {  
    public:  
        // ... a lot of methods ...  
        ...  
    
        /*! includes several bit-fields: 
             - the magic signature 
             - continuity flag 
             - depth 
             - number of channels 
         */  
        int flags;  
        //! the array dimensionality, >= 2  
        int dims;  
        //! the number of rows and columns or (-1, -1) when the array has more than 2 dimensions  
        int rows, cols;  
        //! pointer to the data  
        uchar* data;  
    
        //! pointer to the reference counter;  
        // when array points to user-allocated data, the pointer is NULL  
        int* refcount;  
    
        // other members  
        ...  
    };</span> 

    Mat矩阵中的数据格式

    Mat的存储是逐行存储的,矩阵中的数据类型包括:
    - Mat_对应的是CV_8U
    - Mat_对应的是CV_8U
    - Mat_对应的是CV_8S
    - Mat_对应的是CV_32S
    - Mat_对应的是CV_32F
    - Mat_对应的是CV_64F

    对应的数据深度如下:

    • CV_8U - 8-bit unsigned integers ( 0..255 )
    • CV_8S - 8-bit signed integers ( -128..127 )
    • CV_16U - 16-bit unsigned integers ( 0..65535 )
    • CV_16S - 16-bit signed integers ( -32768..32767 )
    • CV_32S - 32-bit signed integers ( -2147483648..2147483647 )
    • CV_32F - 32-bit floating-point numbers ( -FLT_MAX..FLT_MAX, INF, NAN )
    • CV_64F - 64-bit floating-point numbers ( -DBL_MAX..DBL_MAX, INF, NAN )

    如何创建一个Mat矩阵

    • 使用Mat矩阵的构造函数
    Mat::Mat();//default
    Mat::Mat(int rows,int cols,int type);
    Mat::Mat(Size size,int type);
    Mat::Mat(int rows, int cols,int type,const Scalar& s);
    Mat::Mat(Size size, int type ,const Scalar& s);
    Mat:: Mat(const Mat& m);
    //参数说明:  
    //int rows:高  
    //int cols:宽  
    //int type:参见"Mat类型定义"  
    //Size size:矩阵尺寸,注意宽和高的顺序:Size(cols, rows)  
    //const Scalar& s:用于初始化矩阵元素的数值  
    //const Mat& m:拷贝m的矩阵头给新的Mat对象,但是不复制数据!相当于创建了m的一个引用对象
    
    //例子1:创建100*90的矩阵,矩阵元素为3通道32位浮点型  
    cv::Mat M(100, 90, CV_32FC3);  
    //例子2:使用一维或多维数组来初始化矩阵,  
    double m[3][3] = {{a, b, c}, {d, e, f}, {g, h, i}};  
    cv::Mat M = cv::Mat(3, 3, CV_64F, m);  
    
    //2.使用create函数:  
    Mat a = create(10, 9, CV_16U);  //创建10*9的矩阵,矩阵元素为16位无符号整型  
    //create的一个特殊用法:如果初始化的时候没有传入size的参数,或者后面需要改变size的参数,可以使用create来调整  
    // make 7x7 complex matrix filled with 1+3j.  
    cv::Mat M(7,7,CV_32FC2,Scalar(1,3));  
    // and now turn M to 100x60 15-channel 8-bit matrix.  
    // The old content will be deallocated:隐式使用release()释放  
    M.create(100,60,CV_8UC(15));</span>  
    展开全文
  • Mat矩阵操作,C++

    千次阅读 2019-06-20 11:44:28
    本文章转自... 一、矩阵 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,d...

    本文章转自https://blog.csdn.net/guoming0000/article/details/8629885

    一、矩阵
    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);//I=|I1-I2|;
    A-B;A-s;s-A;-A;
    subtract(I1,I2,dst);
    3.乘法
    I=I.mul(I);//点乘,I.mul(I,3);-->I=3*I.^2
    Mat C=A.mul(5/B);//==divide(A,B,C,5);
    A*B;矩阵相乘
    I=alpha*I;
    Mat::cross(Mat);//三维向量(或矩阵)的叉乘,A.cross(B)
    double Mat::dot(Mat);//2个向量(或矩阵)的点乘的结果,A.dot(B)
    mul-------multiply
    pow(src,double p,dst);//如果p是整数dst(I)=src(I)^p;其他|src(I)|^p
    4.除法
    divide(I1,I2,dst,scale,int dtype=-1);//dst=saturate_cast(I1*scale/I2);
    A/B;alpha/A;都是点除
    5.转换
    I.convertTo(I1,CV_32F);//类型转换
    A.t();//转置
    flip(I,dst,int flipCode);//flipCode=0是上下翻转,>0时左右翻转,<0时一起来
    sqrt(I,dst);
    cvtColor(I,dst,int code,int dstCn=0);
    resize:对图像进行形变
    --------------------------------------------------------------------------
    6.其他
    Scalar s=sum(I);各通道求和
    norm,countNonZero,trace,determinant,repeat都是返回Mat或者Scalar
    countNonZero:用来统计非零的向量个数.(rows*cols个)
    Scalar m=mean(I);//各通道求平均
    Mat RowClone=C.row(1).clone();//复制第2行
    addWeight(I1,alpha,I2,beta,gamma,dst,int dtype=-1);//dst=saturate(alpha*I1+beta*I2+gamma);dtype是dst的深度
    ----------------------------------------------------------------------------
    7.运算符
    log10()
    exp(I,dst);//dst=exp(I);计算每个数组元素的指数
    log(I,dst);//如果Iij!=0;则dstij=log(|Iij|)
    randu(I,Scalar::all(0),Scalar::all(255));
    Mat::t()转置
    Mat::inv(int method=DECOMP_LU)求逆。method=DECOMP_CHOLESKY(专门用于对称,速度是LU的2倍),DECOMP_SVD//A.inv();A.inv()*B;
    invert(I1,dst,int method=DECOMP_LU);//用法同上
    MatExpr abs(Mat)//求绝对值
    A cmpop B;A compop alpha;alpha cmpop A;这里cmpop表示>,>=,==,!=,<=,<等,结果是CV_8UC1的mask的0或255
    按位运算:A logicop B;A logicop s;s logicop A;~A;这里logicop代表&,|,^
    bitwise_not(I,dst,mask);//inverts所有的队列
    还有bitwise_and,bitwise_or,bitwise_xor,
    min(A,B);min(A,alpha);max(A,B);max(A,alpha);都返回MatExpr,返回的dst和A的类型一样
    double determinant(Mat);//行列式
    bool eigen(I1,dst,int lowindex=-1,int highindex=-1);//
    bool eigen(I1,dst,I,int...);//得到特征值向量dst和对应特征值的特征向量
    minMaxLoc(I1,&minVal,&maxVal,Point *minLoc=0,Point* MaxLoc=0,mask);
    //minLoc是2D时距原点最小的点(未考证)
    ------------------------------------------------------------------------------
    8.初始化
    Mat I(img,Rect(10,10,100,100));//用一块地方初始化。
    Mat I=img(Range:all(),Range(1,3));//所有行,1~3列
    Mat I=img.clone();//完全复制
    img.copyTo(I);//传递矩阵头
    Mat I(2,2,CV_8UC3,Scalar(0,0,255));//I=[0,0,255,0,0,255;0,0,255,0,0,255];
    Mat E=Mat::eye(4,4,CV_64F);//对角矩阵
    Mat O=Mat::ones(2,2,CV_32F);//全一矩阵
    Mat Z=Mat::zeros(3,3,CV_8UC1);//全零矩阵
    Mat C=(Mat_<double>(2,2)<<0,-1,2,3);//如果是简单矩阵的初始化
    Mat::row(i);Mat::row(j);Mat::rowRange(start,end);Mat::colRange(start,end);都只是创建个头
    Mat::diag(int d);d=0是是主对角线,d=1是比主低的对角线,d=-1....
    static Mat Mat::diag(const Mat& matD)
    Mat::setTo(Scalar &s);以s初始化矩阵
    Mat::push_back(Mat);在原来的Mat的最后一行后再加几行
    Mat::pop_back(size_t nelems=1);//移出最下面几行
    -------------------------------------------------------------------------------
    9.矩阵读取和修改
    (1)1个通道:
    for(int i=0;i<I.rows;++i)for(int j=0;j<I.cols;++j)I.at<uchar>(i,j)=k;
    (2)3个通道:
    Mat_<Vec3b> _I=I;//他没有4个通道寸,只有3个通道!
    for(int i=0;i<I.rows;++i)for(int j=0;j<I.cols;++j){_I(i,j)[0]=b;_I(i,j)[1]=g;_I(i,j)[2]=r;}I=_I;
    ------------------------------------------------------------
    或者直接用I.at<Vec3b>(i,j)[0]....
    -------------------------------------------------float *s;for(i=0;i<dealImg.rows;i++){s=proImg.ptr<float>(i);for(j=0;j<dealImg.cols;j++){a1=s[3*j+1]-m1;a2=s[3*j+2]-m2;}}
    -------------------------------------------------------------------------
    (3)其他机制
    I.rows(0).setTo(Scalar(0));//把第一行清零
    saturate_cast<uchar>(...);//可以确保内容为0~255的整数
    Mat::total();返回一共的元素数量
    size_t Mat::elemSize();返回元素的大小:CV_16SC3-->3*sizeof(short)-->6
    size_t Mat::elemSize1();返回元素一个通道的大小CV_16SC3-->sizeof(short)-->2
    int Mat::type()返回他的类型CV_16SC3之类
    int Mat::depth()返回深度:CV_16SC3-->CV_16S
    int Mat::channels()返回通道数
    size_t Mat:step1()返回一个被elemSize1()除以过的step
    Size Mat::size()返回Size(cols,rows);如果大于2维,则返回(-1,-1),都是先宽再高的
    bool Mat::empty()如果没有元素返回1,即Mat::total()==0或者Mat::data==NULL
    uchar *Mat::ptr(int i=0)指向第i行
    Mat::at(int i)(int i,int j)(Point pt)(int i,int j,int k)
    RNG随机类:next,float RNG::uniform(float a,float b);..
    double RNG::gaussian(double sigma);
    RNG::fill(I,int distType,Mat low,Mat up);//用随机数填充
    randu(I,low,high);
    randn(I,Mat mean,Mat stddev);
    reduce(I,dst,int dim,int reduceOp,int dtype=-1);//可以统计每行或每列的最大、最小、平均值、和
    setIdentity(dst,Scalar &value=Scalar(1));//把对角线替换为value
    //效果等同:Mat A=Mat::eye(4,3,CV_32F)*5;
    --------------------------------------------------------------
    10.较复杂运算
    gemm(I1,I2,alpha,I3,beta,dst,int flags=0);//I1至少是浮点型,I2同I1,flags用来转置
    //gemm(I1,I2,alpha,I3,beta,dst,GEMM_1_T,GEMM_3_T);-->dst=alpha*I1.t()*I2+beta*I3.t();可用此完全代替此函数
    mulTransposed(I,dst,bool aTa,Mat delta=noArray(),double scale=1,int rtype=-1);
    //I是1通道的,和gemm不同,他可用于任何类型。
    //如果aTa=flase时,dst=scale*(I-delta).t()*(I-delta);
    //如果是true,dst=scale*(I-delta)(I-delta).t();
    calcCovarMatrix(Mat,int,Mat,Mat,int,int=);calcCovarMatrix(Mat I,Mat covar,Mat mean,int flags,int=);
    cartToPolar//转到极坐标
    compare(I1,I2,dst,cmpop);cmpop=CMP_EQ,CMP_GT,CMP_GE,CMP_LT,CMP_LE,COM_NE
    completeSymm(M,bool lowerToUpper=false);当lowerToUpper=true时Mij=Mji(i<j);当为flase时,Mij=Mji(i>j)
    变成可显示图像:convertScaleAbs(I,dst,alpha,beta);dst=saturate_cast<uchar>(|alpha*I+beta|);
    dct(I,dst,int flags=0);//DCT变换,1维、2维的矩阵;flags=DCT_INVERSE,DCT_ROWS
    idct,dft,idft
    inRange(I1,I_low,I_up,dst);//dst是CV_8UC1,在2者之间就是255
    Mahalanobis(vec1,vec2,covar);
    merge(vector<Mat>,Mat);//把多个Mat组合成一个和split相反
    double norm(...):当src2木有时,norm可以计算出最长向量、向量距离和、向量距离和的算术平方根
    solveCubic解3次方程,solvePoly解n次方程
    排列:sort,sortIdx
    mixChannels();对某个通道进行各种传递
    -----------------------------------------------------------------
    11.未懂的函数
    getConvertElem,extractImageCOI,LUT
    magnitude(x,y,dst);//I1,I2都是1维向量,dst=sqrt(x(I)^2+y(I)^2);
    meanStdDev,
    MulSpectrums(I1,I2,dst,flags);傅里叶
    normalize(I,dst,alpha,beta,int normType=NORM_L2,int rtype=-1,mask);//归一化
    PCA,SVD,solve,transform,transpose
    二、其他数据结构
    Point2f P(5,1);
    Point3f P3f(2,6,7);
    vector<float> v;v.push_back((float)CV_PI);v.push_back(2);v.push_back(3.01f);//不断入
    vector<Point2f> vPoints(20);//一次定义20个
    --------------------- 
    作者:延陵小明 
    来源:CSDN 
    原文:https://blog.csdn.net/guoming0000/article/details/8629885 
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • 对OpenCV中的Mat矩阵复制,创建等操作的时间消耗 代码如下: clock_t t1,t2; t1 = clock(); Mat mat1(10000,5000,CV_64FC1,Scalar::all(0.0)); t2 = clock(); cout   { t1 = ...
  • OpenCV3对大型数据的存储,具有代表性的是 cv::Mat和cv::SparseMat 类型。 cv::Mat针对的是密集连续性的存储,大多数的图像数据被存储为这种类,即使数据为空,预留的存储空间仍然存在;而cv::SparseMat针对的是...
  • Opencv之Mat矩阵

    2019-05-13 11:05:48
    对于opencv来说,Mat矩阵是很基础也很重要的数据类型,之前也常常用到,但最近用到的时候,出现一个问题,才意识到之前掌握的知识存在漏洞。 Mat的赋值: 1)以固定大小,固定类型,全0,初始化 Mat fgMask = Mat:...
  • Mat的行复制

    2018-12-10 22:57:31
    Mat的行复制引言法一法二法三 引言 模式识别中,经常需要将所有样本导入到一个矩阵中去。就涉及到将一张图片转为一行数据然后复制到大矩阵中。这里以自己练习中遇到的情况举例:200个图片样本。vectorcv::Mat train...
  • 1、Mat矩阵值传递的时候,如果在函数内部类型发生改变时候,传出来的数据会变化,所以需要在函数内部重新复制一块区域给他,才能传出想要的Mat void getDes(Mat& des) { temp = Mat(10,10,CV_32FC1); temp....
  • Opencv Mat矩阵操作 1. 生成矩阵: Mat image(240, 320, CV8UC3); 第一个参数是rows,该矩阵的行数;第二个参数是cols,该矩阵的列数;第三个参数是该矩阵元素的类型。这句话表示创建一个大小为240×320的矩阵,...
  • opencv中Mat矩阵的合并与拼接

    千次阅读 2019-03-27 15:59:33
    opencv如何将两个矩阵按行或者按列合并 在Matlab中将两个矩阵合并非常方便: 按行合并,如A=[B C]; 按列合并如A=[B ;C] 其实opencv有自带函数:vconcat和hconcat函数,用于矩阵的合并与图像的拼接。 vconcat(B,C...
  • Opencv2.4学习::Mat矩阵的创建

    千次阅读 2018-09-02 16:08:47
    Mat类构造函数:  类详细解释参见:https://blog.csdn.net/qq_37406130/article/details/78725406 1、Mat::Mat()  无参数构造方法;  2、Mat::Mat(int rows, int cols, int type)  创建行数为 rows,列数为 ...
  • opencv Mat元素访问和Mat矩阵初始化

    千次阅读 2015-05-18 14:48:56
    opencv里,Mat图像的像素访问跟 IplImage类型 ... //Mat矩阵中的初始化,可以利用Mat::at()来完成 float m0[]={ 1,2,3, 6,5,4, 7,8,9 }; Mat M0(3,3,CV_32F); InitMat(M0,m0); }
  • 如果定义为 uchar *p=new uchar[9]; Mat a(3,3,CV_8UC1,p);...矩阵之间的复制问题 Mat b=a; 这个是浅复制,即a.release()之后b就无效了。 Mat b; a.copyTo(b); 或者 b=a.clone() 都是深复制,即是数据区会复制一份。
  • 对于R2015a和更新……根据repelem的文档(在R2015a版本中首次引入),它也可以在矩阵上运行....对于R2015a之前的版本……您可以使用this question中的一种方法将索引复制到第三维,然后使用该索引简单地索引矩阵....
  • Opencv学习——Mat矩阵操作

    千次阅读 2017-05-06 17:36:58
    Opencv2出现以后图像的操作可以...一般复制操作只是复制矩阵头和指向矩阵的指针,并不会复制矩阵本身的数据。一些基本操作如下: Mat A, C; //只创建了矩阵头 A = imread(argv[1], CV_LOAD_IMAGE_COLOR); //创建方法
  • Mat OpenCV最开始是使用C语言中的结构体IplImage来存储图像的,但是它的缺点在于需要程序编写者来管理内存的分配与释放。它在小项目中问题不大,一旦有代码变多,处理起来就会变得十分棘手。幸运的是,C++引入了类,...
  • OpenCV中矩阵类详解:Mat

    千次阅读 2017-11-30 10:05:35
    转载自:http://www.xuebuyuan.com/2148247.htmlOpenCV中矩阵类详解之一:Mat综述Mat类可以被看做是opencv中C++版本的矩阵类,替代原来C版本的矩阵结构体CvMat和图像结构体IplImage;Mat最大的优势跟STL的兼容性很好...
  • 介绍 将矩阵从(1, 24, 3, 3)变为(2, 24, 3, 3)。 步骤: pose = tf.tile(MAT, multiples=[2, 1, 1, 1]) MAT 是一个(1, 24, 3, 3)矩阵.
  • Mat矩阵操作1.1 创建矩阵1.2 赋值运算1.3 算术运算2. Mat子矩阵操作2.1子矩阵创建2.2子矩阵赋值3. Mat矩阵变形4. 常用的数据结构与基本图形绘制参考 1. Mat矩阵操作 1.1 创建矩阵 //第一个参数是rows,第二个参数是...
  • 平常用的比较多的是 imread函数,直接将一个.jpg或者.bmp或者其他格式图片文件,读入到mat矩阵中。 本博文记录的是,如何将一段内存,或者文件流,读入到mat矩阵中。 有两个例子,相信看了之后,应该知道该...
  • 在opencv中我们经常用到的是1或者3通道的图像,也就是灰度图像或者彩色图像,对于这两个类型的图像来说,在网上可以找到许多有关的操作。...创建Mat矩阵   //1.使用构造函数,常见的几个如下:
  • 【OpenCV】几种Mat类拷贝复制方法对比

    万次阅读 多人点赞 2019-02-02 13:58:45
    OpenCV中几种常用的Mat类拷贝复制方法对比分析。
  • OpenCV关于Mat图片复制

    千次阅读 2018-09-02 15:14:05
    srcimage.copyTo(firstimage);...Mat 是一个类,由两个数据部分组成:矩阵头(包含矩阵尺寸,存储方法,存储地址等信息)和一个指向存储所有像素值的矩阵(根据所选存储方法的不同矩阵可以是不同的维数)的指针。 ...
  • OpenCV2中,数据结构Mat是保存图像像素信息的矩阵,它主要包   含两部分:矩阵头和一个指向像素数据的矩阵指针。   矩阵头主要包含,矩阵尺寸、存储方法、存储地址和引用次数等。   矩阵头的大小是一个常数...
  • 1--矩阵头--即class Mat类所实例化的类对象所开辟的空间里面存储的数据---就是这个矩阵的信息,当我们以 Mat object;这样声明类对象的时候,也仅仅是创建了一个Mat的信息头,并没有创建矩阵体,也就是说,我们并 ...
  • Mat之间的复制(深拷贝浅拷贝)

    千次阅读 2018-10-10 17:32:10
    浅拷贝 - 不复制数据只创建矩阵头,数据共享(更改a,b,c的任意一个都会对另外2个产生同样的作用) Mat a = imread("1.jpg"); Mat b = a; //a "copy" to b Mat c(a); //a "copy" to c a.col(10)=0;//把a...
  • OpenCV 矩阵复制(copyto,clone)

    千次阅读 2017-03-29 01:03:56
    矩阵之间的复制总结 Mat b=a; 这个是浅复制,即a.release()之后b就无效了。Mat b; a.copyTo(b); 或者 b=a.clone()都是深复制,即是数据区会复制一份。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,208
精华内容 4,083
关键字:

mat矩阵的复制