OpenCv矩阵操作函数大全

                                                            OpenCv矩阵操作函数大全 .


分类： C/C++ opencv 数字图像处理 2012-02-13 20:43 96人阅读 评论(0) 收藏 举报 


OpenCv矩阵操作


有很多函数有mask，代表掩码，如果某位mask是0,那么对应的src的那一位就不计算，mask要和矩阵/ROI/的大小相等


大多数函数支持ROI，如果图像ROI被设置，那么只处理ROI部分


少部分函数支持COI，如果COI设置，只处理感兴趣的通道






矩阵逻辑运算


void cvAnd(const CvArr* src1,const CvArr* src2, CvArr* dst, const CvArr* mask=NULL);//


void cvAndS(const CvArr* src, CvScalar value, CvArr* dst, constCvArr* mask=NULL);//


void cvOr(const CvArr* src1, const CvArr* src2, CvArr* dst, constCvArr* mask=NULL);//


void cvOrS(const CvArr* src, CvScalar value, CvArr* dst, constCvArr* mask=NULL);//


void cvXor(const CvArr* src1, const CvArr* src2, CvArr* dst, constCvArr* mask=NULL);//


void cvXorS(const CvArr* src, CvScalar value, CvArr* dst, constCvArr* mask=NULL);//


void cvNot(const CvArr* src,CvArr* dst);//矩阵取反






矩阵算术运算 绝对值


void cvAbs(const CvArr*src,CvArr* dst);


void cvAbsDiff(const CvArr* src1,const CvArr* src2, CvArr*dst);//两矩阵相减取绝对值


void cvAbsDiffS(const CvArr* src, CvArr* dst,CvScalarvalue);//矩阵减去一个数取绝对值


加减


void cvAdd(const CvArr* src1,const CvArr*src2,CvArr* dst,const CvArr* mask =NULL);//两数组相加，dst(I)=src1(I)+src2(I) if mask(I)!=0


void cvAddS(const CvArr* src,CvScalar value,CvArr*dst,const CvArr*mask = NULL);//数组和一个数相加，dst(I)=src(I)+value if mask(I)!=0


void cvAddWeighted(const CvArr* src1,double alpha,const CvArr*src2,double beta,double gamma,CvArradded to each sum*dst);//带权相加相当于dst(x,y) = α ? src1(x,y) + β ? src2(x,y) + γ


void cvSub(const CvArr* src1, const CvArr* src2, CvArr* dst, constCvArr* mask=NULL);//矩阵减法，dst(I)=src1(I)-src2(I) if mask(I)!=0


void cvSubS(const CvArr* src, CvScalar value, CvArr* dst, constCvArr* mask=NULL);//矩阵减数，dst(I)=src(I)-value if mask(I)!=0


void cvSubRS(const CvArr* src, CvScalar value, CvArr* dst, constCvArr* mask=NULL);//数减矩阵，dst(I)=value-src(I) if mask(I)!=0


乘除


void cvDiv(const CvArr* src1, constCvArr* src2, CvArr* dst, doublescale=1);//scale*src1(i)/src2(i)，如果src1=NULL，则计算scale/src2(i)


void cvMul(const CvArr* src1,const CvArr* src2,CvArr* dst,doublescale=1);//两矩阵元素之间的简单乘法，一般的矩阵点乘用cvGEMM();


次方


void cvPow(const CvArr* src, CvArr* dst,double power);//为每个src的数求power次方


指数


void cvExp(const CvArr* src, CvArr*dst);//dst(I)=EXP(src(I))


对数


void cvLog(const CvArr* src, CvArr*dst);//






线性代数计算 加&乘


voidcvScaleAdd(const CvArr* src1, CvScalar scale, const CvArr* src2,CvArr* dst);//src1和scale的乘积加上src2


void cvCrossProduct(const CvArr* src1,const CvArr* src2,CvArr*dst);//计算两个3D向量（单通道）的叉乘运算


double cvDotProdu ct(const CvArr* src1, const CvArr*src2);//两个向量点乘


void cvGEMM(const CvArr* src1, const CvArr* src2, double alpha,const CvArr* src3, double beta, CvArr* dst, inttABC=0);//乘加运算的始祖


   由通用乘加函数参与定义的两个具体宏


       cvMatMul(const CvArr* src1,const CvArr* src2,CvArr* dst);


       cvMatMulAdd(const CvArr* src1,const CvArr* src2,const CvArr*src3,CvArr* dst);


CvScalar cvTrace(const CvArr* mat);//计算对角线上的元素和


变换


void cvTransform(const CvArr* src, CvArr*dst, const CvMat* transmat, const CvMat*shiftvec=NULL);//dst=transmat · src + shiftvec


void cvPerspectiveTransform(const CvArr* src, CvArr* dst, constCvMat* mat);//把矩阵每个元素中三个通道当做一个矩阵，乘mat，mat是一个3×3或者4×4的转换矩阵


转置


void cvTranspose(const CvArr* src, CvArr*dst);


void cvMulTransposed(const CvArr* src, CvArr* dst, int order, constCvArr* delta=NULL, doublescale=1.0);//(src-delta)乘以它的转置再乘以scale


逆矩阵


double cvInvert(const CvArr* src,CvArr*dst,int method=CV_LU);//求原矩阵的逆矩阵，默认使用高斯消去法


   方阵可逆的充要条件是|A|!=0


   method取值为CV_LU高斯消去法（默认）   CV_SVD奇异值分解SVD   CV_SVD_SYM对称矩阵的SVD


行列式


double cvDet(const CvArr*mat);//计算方阵行列式，一定是单通道的


   小型方阵直接计算，大型方阵用高斯消去法计算


   如果矩阵正定对称，用奇异值分解的方法解决cvSVD();


特征向量特征值


void cvEigenVV(CvArr* mat, CvArr*evects, CvArr* evals, doubleeps=0);//计算对称矩阵的特征值和特征向量，evects输出特征向量，evals输出特征值，eps雅可比方法停止参数


   要求三个矩阵都是浮点类型，10×10以下该方法有效，20×20以上的矩阵不能计算出结果，为节约计算量，eps通常设为DBL_EPSILON(10^-15)


   如果给定的矩阵是对称正定矩阵，那么考虑使用cvSVD();


协方差


void cvCalcCovarMatrix(const CvArr**vects, int count, CvArr* cov_mat, CvArr* avg, intflags);//给定一组大小和类型相同的向量，向量的个数，计算标记，输出协方差正阵和每个向量的平均值矩阵


   CV_COVAR_NORMAL   普通计算协方差和平均值，输出的是n×n的协方差阵


   CV_COVAR_SCRAMBLED   快速PCA“Scrambled”协方差，输出的是m×m的协方差阵


   CV_COVAR_USE_AVERAGE   平均值是输入的


   CV_COVAR_SCALE   重新缩放输出的协方差矩阵


       四个flag通过并运算协同发挥作用，前两个不能并


CvSize cvMahalonobis(const CvArr* vec1,const CvArr* vec2,CvArr*mat);


int cvSolve(const CvArr* src1, const CvArr* src2, CvArr* dst, intmethod=CV_LU);//Solves a linear system or least-squaresproblem.


void cvSVD(CvArr* A, CvArr* W, CvArr* U=NULL, CvArr* V=NULL, intflags=0);//Performs singular value decomposition of a realfloating-point matrix.


void cvSVBkSb(const CvArr* W, const CvArr* U, const CvA rr* V, constCvArr* B, CvArr* X, int flags);//Performs singular value backsubstitution.






数组比较


void cvCmp(const CvArr* src1, constCvArr* src2, CvArr* dst, int cmp_op);//两矩阵比较运算


    CV_CMP_EQ -src1(I) 是否相等


    CV_CMP_GT -src1(I) 是否大于


    CV_CMP_GE -src1(I) 是否大于等于


    CV_CMP_LT -src1(I) 是否小于


    CV_CMP_LE -src1(I) 是否小于等于


    CV_CMP_NE -src1(I) 是否不等


       如果判断为假，dst设为0，如果判断为真，dst设为0xff


void cvCmpS(const CvArr* src, double value, CvArr* dst, intcmp_op);//矩阵和一个数字比较运算






矩阵内转换 类型转换


void cvConvertScale(constCvArr* src,CvArr* dst,double scale,doubleshift);//矩阵首先乘以scale再加上shift，然后把src中的数据类型转换成dst类型，但是src和dst通道数需要相等


void cvConvertScaleAbs(const CvArr* src,CvArr* dst,doublescale,double shift);//在src到dst类型转换前，先做绝对值


void cvCvtColor(const CvArr* src,CvArr* dst, int code);//图像颜色空间转换，src要为8U 16U 32F，dst的数据类型需要和src相同，通道数看code


   code格式如：CV_原色彩空间2目的色彩空间   色彩空间要考虑RGB的顺序


   支持的颜色空间包括：RGB   RGB565   RGB555    GRAYRGBA   XYZ   YCrCb   HSV   HLS   Luv   BayerRG


空间转换


void cvFlip(const CvArr* src, CvArr*dst=NULL, intflip_mode=0);//图像绕x、y轴旋转。当用在一维数组上时并且flip_mode>0，可以用来颠倒数据排列


   flip_mode=0：左右对称values of the conversion resul


   flip_mode>0：上下对称


   flip_mode<0：中心对称






矩阵间操作 void cvCopy(const CvArr* src,CvArr*dst,const CvArr* mask=NULL);


void cvMerge(const CvArr* src0,const CvArr* src1,const CvArr*src2,const CvArr* src3,CvArr*dst);//多个数组合并成一个，类型和尺寸都相同，dst有多个通道，src可以赋值NULL


void cvSplit(cosnt CvArr* src,CvArr* dst0,CvArr* dst1,CvArr*dst2,CvArr* dst3);//一个多通道数组分解成多个数组，类型尺寸都想同，dst可以赋值NULL


void cvRepeat(const CvArr* src, CvArr*dst);//在dst中重复叠加src，dst(i,j)=src(i mod rows(src), j modcols(src))


CvMat* cvReshape(const CvArr* originalarr, CvMat* headerdata, intnew_cn, intnew_rows=0);//把一个originalarr（可以是已经有内容的图片），转换为有新的通道数、新的行数的数据（CvMat*只含数据，没有图片头）


CvArr* cvReshapeMatND(const CvArr* arr, int sizeof_header, CvArr*header, int new_cn, int new_dims, int* new_sizes);


void cvLUT(const CvArr* src, CvArr* dst, const CvArr*lut);//src是8bit类型的数据，lut是一张一维查找表，拥有256个通道数类型和dst相同的元素，src的某一位置的元素数值n，到lut的n位置查找的内容填入dst的相应src的n元素的位置






统计运算 最大最小


void cvMax(const CvArr* src1,const CvArr* src2, CvArr* dst);


void cvMaxS(const CvArr* src, double value, CvA rr*dst);//找较大值放到dst中


void cvMin(const CvArr* src1,const CvArr* src2,CvArr* dst);


void cvMins(const CvArr* src,double value,CvArr*dst);//找较小值放到dst中


void cvMinMaxLoc(const CvArr* arr, double* min_val, double*max_val, CvPoint* min_loc=NULL, CvPoint* max_loc=NULL, const CvArr*mask=NULL);


   找出全局某个通道中最大最小的值，和她们的位置，如果不止一个通道，一定要设置COI


零的个数


int cvCountNonZero( const CvArr* arr);//统计非零的个数


是否落在范围内


void cvInRange(const CvArr*src,const CvArr* lower,const CvArr* upper,CvArr* dst);


void cvInRangeS(const CvArr* src,CvScalar lower,CvScalarupper,CvArr* dst);//判断原数组中的每个数大小是否落在对应的lower、upper数组位置数值的中间


    if(lower(i)<=src(i)<upper(i) ){dst(i)=0xff; }else{ dst(i)=0; }


平均值标准差


CvScalar cvAvg(const CvArr* arr,constCvArr* mask =NULL);//计算mask非零位置的所有元素的平均值，如果是图片，则单独计算每个通道上的平均值，如果COI设置了，只计算该COI通道的平均值


void cvAvgSdv(const CvArr* arr, CvScalar* mean, CvScalar* std_dev,const CvArr* mask=NULL);//计算各通道的平均值，标准差，支持COI






double cvNorm(const CvArr* arr1,const CvArr* arr2=NULL,intnorm_type=CV_L2,const CvArr* mask=NULL);//计算一个数组的各种范数


   如果arr2为NULL，norm_type为


       CV_C 求所有数取绝对值后的最大值，CV_L1 求所有数的绝对值的和，CV_L2求所有数的平方和的平方根


   如果arr2不为NULL，norm_type为


       CV_Carr1和arr2对应元素差的绝对值中的最大值   CV_L1arr1和arr2对应元素差的绝对值的和   CV_L2 arr1和arr2的差平方和的平方根


       CV_RELATIVE_C   CV_RELATIVE_L1   CV_RELATIVE_L2 上面结果除以cvNorm(arr2,NULL,对应的norm_type);


cvNormalize(const CvArr* src,CvArr* dst,double a=1.0,doubleb=0.0,int norm_type=CV_L2,const CvArr* mask=NULL);


   CV_C   CV_L1   CV_L2   CV_MINMAX


cvReduce(const CvArr* src,CvArr* dst,int dim,intop=CV_REDUCE_SUM);//根据一定规则，把矩阵约简为向量


   dim   决定约简到行还是列   1:约简到单个列，0:约简到单个行，-1:根据dst的CvSize，决定约简到行还是列


   op   决定按什么规则约简


       CV_REDUCE_SUM - 行/列的和


       CV_REDUCE_AVG-   行/列平均值


       CV_REDUCE_MAX - 行/列中最大值


       CV_REDUCE_MIN-    行/列中最小值






取得设置数组信息 得到指定行列


CvMat* cvGetCol(constCvArr* arr,CvMat* submat,int col);


CvMat* cvGetCols(const CvArr* arr,CvMat* submat,int start_col,intend_col);//取目标矩阵的某列/连续几列，submat和返回值的实际数据还是在原矩阵中，只是修改了头部和数据指针，没有数据拷贝


CvMat* cvGetRow(const CvArr* arr,CvMat* submat,int row);


CvMat* cvGetRows(const CvArr* arr,CvMat* submat,int start_row,intend_row);


得到对角线


CvMat* cvGetDiag(const  CvArr*arr,CvMat* submat,intdiag=0);//取矩阵arr的对角线，结果放在向量中，并不要求原矩阵是方阵，diag表示从哪个位置开始取对角线


维度大小


int cvGetDims(const CvArr* arr,int*sizes=NULL);//获取数组的维数和每一维的大小，sizes十一个数组的头指针。图像或者矩阵的维数一定是2，先行数后列数


int cvGetDimSize(const CvArr* arr,int index);//获取某一维的大小


矩阵大小


CvSize cvGetSize(const CvArr*arr);//返回矩阵和图像的大小。小的结构体一般都是直接返回值而不是重新分配指针，分配指针的效率可能比直接返回值效率更低


截取矩形矩阵


CvMat* cvGetSubRect(const CvArr* arr,CvMat* submat, CvRectrect);//从输入的数组中根据输入的矩形截取一块数组中的矩形，返回的CvMat*就是submat


得到和设置元素       因为效率原因，实际很少会直接用到这些方法，而是根据实际的应用来决定如何操作每一个数


uchar* cvPtr1D(CvArr* arr,int idx0,int*type);//得到的是指针，所以可以修改，比下面的效率更高


uchar* cvPtr2D(CvArr* arr,int idx0,int idx1,int* type);


uchar* cvPtr3D(CvArr* arr,int idx0,int idx1,int idx2,int*type);


uchar* cvPtrND(CvArr* arr,int* idx,int* type,intcreate_node=1,unsigned* precalc_hashval=NULL);//int*idx是一个数组指针，里面保存着索引


double cvGetReal1D(const CvArr* arr,int idx0);//得到的是具体值


double cvGetReal2D(const CvArr* arr,int idx0,int idx1);


double cvGetReal3D(const CvArr* arr,int idx0,int idx1,intidx2);


double cvGetRealND(const CvArr* arr,int* idx);


CvScalar cvGet1D(const CvArr* arr,int idx0);


CvScalar cvGet2D(const CvArr* arr,int idx0,int idx1);


CvScalar cvGet3D(const CvArr* arr,int idx0,int idx1,intidx2);


CvScalar cvGetND(const CvArr* arr,int* idx);


double cvmGet(const CvMat* mat, int row, intcol);//仅仅用于矩阵单通道浮点数的获取，由于是inline并且没有类型判断，所以效率比较高


void cvSetReal1D(CvArr* arr, int idx0, double value);


void cvSetReal2D(CvArr* arr, int idx0, int idx1, doublevalue);


void cvSetReal3D(CvArr* arr, int idx0, int idx1, int idx2, doublevalue);


void cvSetRealND(CvArr* arr, int* idx, double value);


void cvSet1D(CvArr* arr, int idx0, CvScalar value);


void cvSet2D(CvArr* arr, int idx0, int idx1, CvScalar value);


void cvSet3D(CvArr* arr, int idx0, int idx1, int idx2, CvScalarvalue);


void cvSetND(CvArr* arr, int* idx, CvScalar value);


void cvmSet(CvMat* mat, int row, int col, doublevalue);//仅仅用于设置单通道浮点类型的矩阵


void cvClearND(CvArr* arr, int* idx);//把多维数组的某位置设置为0


void cvSet(CvArr* arr, CvScalar value, const CvArr*mask=NULL);//把数组每个元素都设为value


void cvSetZero(CvArr* arr);//对普通矩阵，每位都设为0；对稀疏矩阵，删除所以元素






一般算数运算 int cvRound(double value ); int cvFloor(double value ); int cvCeil( doublevalue);//求和double最 （上/下）接近的整数


float cvSqrt(float value);//求平方根


float cvInvSqrt(float value);//求平方根倒数


float cvCbrt(float value);//求立方根


float cvCbrt(float value);//求两个向量的夹角


int cvIsNaN(double value);//判断是否是合法数


int cvIsInf(double value);//判断是否无穷


void cvCartToPolar(const CvArr* x, const CvArr* y, CvArr*magnitude, CvArr* angle=NULL, int angle_in_degrees=0);//


void cvPolarToCart(const CvArr* magnitude, const CvArr* angle,CvArr* x, CvArr* y, int angle_in_degrees=0);//


void cvSolveCubic(const CvArr* coeffs, CvArr*roots);//求三次方方程解，coeffs作为三次方程的系数，可以是三元（三次方系数为1）或者四元






随机数生成 CvRNG cvRNG(int64seed=-1);//生成随机数生成器


unsigned cvRandInt(CvRNG* rng);


double cvRandReal(CvRNG* rng);


void cvRandArr(CvRNG* rng, CvArr* arr, int dist_type, CvScalarparam1, CvScalar param2);//


   dist_type决定生成随机数组中的分布   CV_RAND_UNI均匀分布   CV_RAND_NORMAL正态/高斯分布


   param1：均匀分布中的下界（包含），正态分布中的平均值


   param2：均匀分布中的上界（不包含），正态分布中的偏差






分布转换


void cvDFT(const CvArr* src, CvArr*dst, int flags, int nonzero_rows=0);


int cvGetOptimalDFTSize(int size0);


void cvMulSpectrums(const CvArr* src1, const CvArr* src2, CvArr*dst, int flags);


void cvDCT(const CvArr* src, CvArr* dst, int flags);