Opencv中对矩阵的操作

Opencv中对矩阵的操作

有很多函数有mask，代表掩码，如果某位mask是0,那么对应的src的那一位就不计算，mask要和矩阵/ROI/的大小相等 
大多数函数支持ROI，如果图像ROI被设置，那么只处理ROI部分 
少部分函数支持COI，如果COI设置，只处理感兴趣的通道

函数

Description

说明

cvAdd

Elementwise addition of two arrays

两个数组对应元素的和

cvAddS

Elementwise addition of an array and a scalar

一个数组和一个标量对应元素的和

cvAddWeighted

Elementwise weighted addition of two arrays (alpha blending)

两个数组对元素的加权求和（alpha混合）

cvSub

Elementwise subtraction of one array from another

把两个数组的对应元素相减

cvSubS

Elementwise subtraction of a scalar from an array

把一个数组的元素减去一个标量

cvSubRS

Elementwise subtraction of an array from a scalar

把一个标量减去一个数组中的元素

cvMul

Elementwise multiplication of two arrays

两个数组对应元素的乘法

cvDotProduct

Compute dot product of two vectors

计算两个向量的点乘

cvCrossProduct

Compute cross product of two three-dimensional vectors

对两个三维向量做叉乘

cvGEMM

Generalized matrix multiplication

广义矩阵的乘法

cvDiv

Elementwise division of one array by another

一个数组和另一个数组对应元素的除法

cvAbs

Absolute value of all elements in an array

数组中所有元素的绝对值

cvAbsDiff

Absolute value of diff erences between two arrays

两个数组差值的绝对值

cvAbsDiffS

Absolute value of diff erence between an array and a scalar

一个数组和一个标量的差值的绝对值

cvMin

Elementwise min operation on two arrays

对两个数组中的对应元素做最小值操作

cvMinS

Elementwise min operation between an array and a scalar

一个数组的元素和一个向量做最小值操作

cvMax

Elementwise max operation on two arrays

对两个数组中的对应元素做最大值操作

cvMaxS

Elementwise max operation between an array and a scalar

一个数组的元素和一个向量做最大值操作

cvMinMaxLoc

Find minimum and maximum values in an array

寻找数组中的最大值和最小值

cvAvg

Average value of all elements in an array

数组中所有元素的平均值

cvAvgStd

Absolute value and standard deviation of all elements in an array

数组中所有元素的平均值和标准差

cvSum

Sum all elements of an array

对数组的所有元素求和

cvCountNonZero

Count nonzero elements in an array

对数组中非零元素计数

cvGetRow

Copy elements from row slice of an array

拷贝数组中一行元素

cvGetRows

Copy elements from multiple adjacent rows of an array

拷贝数组中相邻的多行元素

cvGetCol

Copy elements from column slice of an array

拷贝数组中一列元素

cvGetCols

Copy elements from multiple adjacent columns of an array

拷贝数组中相邻的多列元素

cvGetSubRect

Copy elements from subregion of an array

拷贝一个数组中子区域的元素

cvGetDiag

Copy elements from an array diagonal

拷贝数组对角线元素

cvAnd

Elementwise bit-level AND of two arrays

把两个数组的对应元素做位与操作

cvNot

Bitwise inversion of every element of an array

对数组中每个元素逐位取反

cvOr

Elementwise bit-level OR of two arrays

把两个数组的对应元素做位取反

cvOrS

Elementwise bit-level OR of an array and a scalar

把一个数组中的元素和一个标量取反

cvXor

Elementwise bit-level XOR between two arrays

把两个数组中的对应元素做异或运算

cvXorS

Elementwise bit-level XOR between an array and a scalar

把一个数组中的元素和一个标量做异或运算

cvGetDims

Return the number of dimensions of an array

返回数组的维数

cvGetDimSize

Return the sizes of all dimensions of an array

返回数组所有维的尺寸

cvGetSize

Get size of a two-dimensional array and return as CvSize

获取二维数组的尺寸，返回一个CvSize结构

cvCopy

Copy elements of one array to another

把一个数组中的元素拷贝到另一个数组

cvRepeat

Tile the contents of one array into another

把一个数组的内容铺到另一个中

cvSplit

Split a multichannel array into multiple single-channel arrays

把一个多通道数组分解为多个单通道数组

cvMerge

Merge several single-channel images into one multichannel image

把数个单通道图象合并为一个多通道图象

cvCvtColor

Convert channels of an array from one color space to another

把数组中通道从一个色彩空间转换到另一个色彩空间

cvReduce

Reduce a two-dimensional array to a vector by a given operation

根据一个给定操作，把一个二维数组缩减为一个向量

cvConvertScale

Convert array type with optional rescaling of the value

 

cvConvertScaleAbs

Convert array type after absolute value with optional rescaling

 

cvSet

Set all elements of an array to a given value

把数组中所有元素赋一个给定的值

cvSetZero

Set all elements of an array to 0

把数组中所有元素赋值为0

cvZero

Set all elements of an array to 0

把数组中所有元素置0

cvFlip

Flip an array about a selected axis

把数组相对一个选定的轴做翻转

cvNormalize

Normalize elements in an array to some value

把数组中的元素规一化到某一值

cvTranspose

Transpose all elements of an array across the diagonal

把所有元素相对对角线转置

cvSetIdentity

Set all elements of an array to 1 for the diagonal and 0 otherwise

对数组的对角线元素赋1，其它的为0

cvCalcCovarMatrix

Compute covariance of a set of n-dimensional vectors

一组n维向量的协方差

cvDet

Compute determinant of a square matrix

计算一个方阵行列式的值

cvEigenVV

Compute eigenvalues and eigenvectors of a square matrix

计算一个方阵的特征值和特征向量

cvInvert

Invert a square matrix

计算方阵的逆矩阵

cvMahalonobis

Compute Mahalonobis distance between two vectors

计算两个向量的马氏距离（Mahalonobis distance）

cvNorm

Compute normalized correlations between two arrays

计算两相数组的规一化系数

cvSVD

Compute singular value decomposition of a two-dimensional array

计算一个二维数组的奇异值分解

cvSVBkSb

Compute singular value back-substitution

计算奇异值回代

cvTrace

Compute the trace of an array

计算数组的迹

cvSolve

Solve a system of linear equations

求解一个线性方程

cvInRange

Test if elements of an array are within values of two other arrays

测试一个数组中的元素的值是否在另两个数组的值之间

cvInRangeS

Test if elements of an array are in range between two scalars

测试一个数组上的元素是否在两个标量之间

cvCmp

Apply selected comparison operator to all elements in two arrays

对两个数组中所有元素进行选中的比较操作

cvCmpS

Apply selected comparison operator to an array relative to a scalar

一个数组和一个标量之间进行选中的比较操作

矩阵逻辑运算 
void cvAnd(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL);// 
void cvAndS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);// 
void cvOr(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL);// 
void cvOrS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);// 
void cvXor(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL);// 
void cvXorS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* 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,CvScalar value);//矩阵减去一个数取绝对值 
加减 
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, const CvArr* mask=NULL);//矩阵减法，dst(I)=src1(I)-src2(I) if mask(I)!=0 
void cvSubS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);//矩阵减数，dst(I)=src(I)-value if mask(I)!=0 
void cvSubRS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);//数减矩阵，dst(I)=value-src(I) if mask(I)!=0 
乘除 
void cvDiv(const CvArr* src1, const CvArr* src2, CvArr* dst, double scale=1);//scale*src1(i)/src2(i)，如果src1=NULL，则计算scale/src2(i) 
void cvMul(const CvArr* src1,const CvArr* src2,CvArr* dst,double scale=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);//

 

线性代数计算 
加&乘 
void cvScaleAdd(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 cvDotProduct(const CvArr* src1, const CvArr* src2);//两个向量点乘 
void cvGEMM(const CvArr* src1, const CvArr* src2, double alpha, const CvArr* src3, double beta, CvArr* dst, int tABC=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, const CvMat* mat);//把矩阵每个元素中三个通道当做一个矩阵，乘mat，mat是一个3×3或者4×4的转换矩阵 
转置 
void cvTranspose(const CvArr* src, CvArr* dst); 
void cvMulTransposed(const CvArr* src, CvArr* dst, int order, const CvArr* delta=NULL, double scale=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, double eps=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, int flags);//给定一组大小和类型相同的向量，向量的个数，计算标记，输出协方差正阵和每个向量的平均值矩阵 
    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, int method=CV_LU);//Solves a linear system or least-squares problem. 
void cvSVD(CvArr* A, CvArr* W, CvArr* U=NULL, CvArr* V=NULL, int flags=0);//Performs singular value decomposition of a real floating-point matrix. 
void cvSVBkSb(const CvArr* W, const CvArr* U, const CvArr* V, const CvArr* B, CvArr* X, int flags);//Performs singular value back substitution.

 

数组比较 
void cvCmp(const CvArr* src1, const CvArr* 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, int cmp_op);//矩阵和一个数字比较运算

 

矩阵内转换 
类型转换 
void cvConvertScale(const CvArr* src,CvArr* dst,double scale,double shift);//矩阵首先乘以scale再加上shift，然后把src中的数据类型转换成dst类型，但是src和dst通道数需要相等 
void cvConvertScaleAbs(const CvArr* src,CvArr* dst,double scale,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    GRAY RGBA    XYZ    YCrCb    HSV    HLS    Luv    BayerRG 
空间转换 
void cvFlip(const CvArr* src, CvArr* dst=NULL, int flip_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 mod cols(src)) 
CvMat* cvReshape(const CvArr* originalarr, CvMat* headerdata, int new_cn, int new_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, CvArr* 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,CvScalar upper,CvArr* dst);//判断原数组中的每个数大小是否落在对应的lower、upper数组位置数值的中间 
    if( lower(i)<=src(i)<upper(i) ){ dst(i)=0xff; }else{ dst(i)=0; } 
平均值标准差 
CvScalar cvAvg(const CvArr* arr,const CvArr* 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,int norm_type=CV_L2,const CvArr* mask=NULL);//计算一个数组的各种范数 
    如果arr2为NULL，norm_type为 
        CV_C 求所有数取绝对值后的最大值，CV_L1 求所有数的绝对值的和，CV_L2求所有数的平方和的平方根 
    如果arr2不为NULL，norm_type为 
        CV_C arr1和arr2对应元素差的绝对值中的最大值    CV_L1 arr1和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,double b=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,int op=CV_REDUCE_SUM);//根据一定规则，把矩阵约简为向量 
    dim    决定约简到行还是列    1:约简到单个列，0:约简到单个行，-1:根据dst的CvSize，决定约简到行还是列 
    op    决定按什么规则约简 
        CV_REDUCE_SUM - 行/列的和 
        CV_REDUCE_AVG  -    行/列平均值 
        CV_REDUCE_MAX - 行/列中最大值 
        CV_REDUCE_MIN  -    行/列中最小值

 

取得设置数组信息 
得到指定行列 
CvMat* cvGetCol(const CvArr* arr,CvMat* submat,int col); 
CvMat* cvGetCols(const CvArr* arr,CvMat* submat,int start_col,int end_col);//取目标矩阵的某列/连续几列，submat和返回值的实际数据还是在原矩阵中，只是修改了头部和数据指针，没有数据拷贝
CvMat* cvGetRow(const CvArr* arr,CvMat* submat,int row); 
CvMat* cvGetRows(const CvArr* arr,CvMat* submat,int start_row,int end_row); 
得到对角线 
CvMat* cvGetDiag(const CvArr* arr,CvMat* submat,int diag=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, CvRect rect);//从输入的数组中根据输入的矩形截取一块数组中的矩形，返回的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,int create_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,int idx2); 
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,int idx2); 
CvScalar cvGetND(const CvArr* arr,int* idx); 
double cvmGet(const CvMat* mat, int row, int col);//仅仅用于矩阵单通道浮点数的获取，由于是inline并且没有类型判断，所以效率比较高 
void cvSetReal1D(CvArr* arr, int idx0, double value); 
void cvSetReal2D(CvArr* arr, int idx0, int idx1, double value); 
void cvSetReal3D(CvArr* arr, int idx0, int idx1, int idx2, double value); 
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, CvScalar value); 
void cvSetND(CvArr* arr, int* idx, CvScalar value); 
void cvmSet(CvMat* mat, int row, int col, double value);//仅仅用于设置单通道浮点类型的矩阵 
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( double value);//求和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(int64 seed=-1);//生成随机数生成器 
unsigned cvRandInt(CvRNG* rng); 
double cvRandReal(CvRNG* rng); 
void cvRandArr(CvRNG* rng, CvArr* arr, int dist_type, CvScalar param1, 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);