有很多函數有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 cvDotProduct(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 CvArr* 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, 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,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);
轉載： http://hi.baidu.com/Ҳ������¿/blog/item/f660c31409559a09972b43ee.html
在OpenCV中有三種方式訪問矩陣中的數據元素：容易的方式，困難的方式，以及正確的方式。以下先講容易的方式和困難的方式。
容易的方式
最容易的方式是使用宏CV_MAT_ELEM( matrix, elemtype, row, col ),輸入參數是矩陣的指針，矩陣元素類型，行，列，返回值是相應行，列的矩陣元素，例如：
CvMat* mat = cvCreateMat(5,5,CV_32FC1);
float element = CV_MAT_ELEM(*mat,float,3,2);
以下是一個例子：
#pragma comment( lib, "cxcore.lib" )
#include "cv.h"
#include <stdio.h>
void main()
{
CvMat* mat = cvCreateMat(3,3,CV_32FC1);
cvZero(mat);//將矩陣置0
//爲矩陣元素賦值
CV_MAT_ELEM( *mat, float, 0, 0 ) = 1.f;
CV_MAT_ELEM( *mat, float, 0, 1 ) = 2.f;
CV_MAT_ELEM( *mat, float, 0, 2 ) = 3.f;
CV_MAT_ELEM( *mat, float, 1, 0 ) = 4.f;
CV_MAT_ELEM( *mat, float, 1, 1 ) = 5.f;
CV_MAT_ELEM( *mat, float, 1, 2 ) = 6.f;
CV_MAT_ELEM( *mat, float, 2, 0 ) = 7.f;
CV_MAT_ELEM( *mat, float, 2, 1 ) = 8.f;
CV_MAT_ELEM( *mat, float, 2, 2 ) = 9.f;
//獲得矩陣元素的值
float element = CV_MAT_ELEM(*mat,float,2,2);
printf("%f/n",element);
}
CV_MAT_ELEM宏實際上會調用CV_MAT_ELEM_PTR(matrix,row,col)宏來完成任務。CV_MAT_ELEM_PTR()宏的參數是矩陣的指針，行，列。
CV_MAT_ELEM()宏和CV_MAT_ELEM_PTR()宏的區別是，在調用CV_MAT_ELEM時，指向矩陣元素的指針的數據類型已經依據輸入參數中的元素類型而
做了強制轉換。，以下是使用CV_MAT_ELEM_PTR()來設置元素的值：
#pragma comment( lib, "cxcore.lib" )
#include "cv.h"
#include <stdio.h>
void main()
{
CvMat* mat = cvCreateMat(3,3,CV_32FC1);
cvZero(mat);//將矩陣置0
float element_0_2 = 7.7f;
*((float*)CV_MAT_ELEM_PTR( *mat, 0, 2 ) ) = element_0_2;
//獲得矩陣元素的值
float element = CV_MAT_ELEM(*mat,float,0,2);
printf("%f/n",element);
}
以上使用矩陣中元素的方式很方便，但不幸的是，該宏在每次調用時，都會重新計算指針的位置。這意味着，先查找矩陣數據區中第0個元素的位置，然後，根據參數中的行和列，計算所需要的元素的地址偏移量，然後將地址偏移量與第0個元素的地址相加，獲得所需要的元素的地址。
所以，以上的方式雖然很容易使用，但是卻不是獲得矩陣元素的最好方式。特別是當你要順序遍歷整個矩陣中所有元素時，這種每次對地址的重複計算就更加顯得不合理。
困難的方式
以上兩個宏只適合獲得一維或二維的矩陣（數組）元素，OpenCV提供了處理多維矩陣(數組)的方式。實際上你可以不受限制地使用N維。
當訪問這樣一種N維矩陣中元素時，你需要使用一個系列的函數，叫做cvPtr*D,*代表1,2,3,4....,例如，cvPtr1D(),cvPtr2D(),cvPtr3D(),以及cvPtrND().以下爲此係列函數的定義：
cvPtr*D函數用於返回指向某數組元素的指針
uchar* cvPtr1D( const CvArr* arr, int idx0, int* type=NULL );
uchar* cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type=NULL );
uchar* cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2, int* type=NULL );
uchar* cvPtrND( const CvArr* arr, int* idx, int* type=NULL, int create_node=1, unsigned* precalc_hashval=NULL );
arr
輸入數組(矩陣).
idx0
元素下標的第一個以0爲基準的成員
idx1
元素下標的第二個以0爲基準的成員
idx2
元素下標的第三個以0爲基準的成員
idx
數組元素下標
type
可選的，表示輸出參數的數據類型
create_node
可選的，爲稀疏矩陣輸入的參數。如果這個參數非零就意味着被需要的元素如果不存在就會被創建。
precalc_hashval
可選的，爲稀疏矩陣設置的輸入參數。如果這個指針非NULL，函數不會重新計算節點的HASH值，而是從指定位置獲取。這種方法有利於提高智能組合數據的操作
函數cvPtr*D 返回指向特殊數組元素的指針。數組維數應該與傳遞給函數的下標數相匹配，它可以被用於順序存取的1D，2D或nD密集數組
函數也可以用於稀疏數組，並且如果被需要的節點不存在函數可以創建這個節點並設置爲0
就像其它獲取數組元素的函數 (cvGet[Real]*D, cvSet[Real]*D)如果元素的下標超出了範圍就會產生錯誤
很明顯，如果是一維數組(矩陣)，那就可以使用cvPtr1D，用參數idx0來指向要獲得的第idx0個元素，返回值爲指向該元素的指針，如果是二維數組(矩陣)，就可以使用cvPtr2D,用idx0，idx1來指向相應的元素。
如果是N維數組，則int* idx參數指向對N維數組中某元素定位用的下標序列。
#pragma comment( lib, "cxcore.lib" )
#include "cv.h"
#include <stdio.h>
void main()
{
CvMat* mat = cvCreateMat(3,3,CV_32FC1);
cvZero(mat);//將矩陣置0
//爲矩陣元素賦值
CV_MAT_ELEM( *mat, float, 0, 0 ) = 1.f;
CV_MAT_ELEM( *mat, float, 0, 1 ) = 2.f;
CV_MAT_ELEM( *mat, float, 0, 2 ) = 3.f;
CV_MAT_ELEM( *mat, float, 1, 0 ) = 4.f;
CV_MAT_ELEM( *mat, float, 1, 1 ) = 5.f;
CV_MAT_ELEM( *mat, float, 1, 2 ) = 6.f;
CV_MAT_ELEM( *mat, float, 2, 0 ) = 7.f;
CV_MAT_ELEM( *mat, float, 2, 1 ) = 8.f;
CV_MAT_ELEM( *mat, float, 2, 2 ) = 9.f;
//獲得矩陣元素(0,2)的值
float *p = (float*)cvPtr2D(mat, 0, 2);
printf("%f/n",*p);
}
我們使用cvPtr*D()函數的一個理由是，通過此函數，我們可以用指針指向矩陣中的某元素，並使用指針運算符，來設置該元素的值，或者，用指針運算來移動指針，指向從起始位置開始的矩陣中的其他元素。例如，我們可以用以下方式遍歷矩陣中的元素：
#pragma comment( lib, "cxcore.lib" )
#include "cv.h"
#include <stdio.h>
void main()
{
CvMat* mat = cvCreateMat(3,3,CV_32FC1);
cvZero(mat);//將矩陣置0
//獲得矩陣元素(0,0)的指針
float *p = (float*)cvPtr2D(mat, 0, 0);
//爲矩陣賦值
for(int i = 0; i < 9; i++)
{
*p = (float)i;
p++;
}
//打印矩陣的值
p = (float*)cvPtr2D(mat, 0, 0);
for(i = 0; i < 9; i++)
{
printf("%f/t",*p);
p++;
if((i+1) % 3 == 0)
printf("/n");
}
}
但是要注意，以上爲矩陣中元素的通道數爲1時，可以用p++來訪問下一個矩陣中元素，但是如果通道數不爲1，例如一個三通道的二維矩陣，矩陣中每個元素的值爲RGB值，則矩陣中數據按以下方式存儲：rgbrgbrgb......,因此，使用指針指向下一個元素時，就需要加上相應的通道數。
舉例如下：
#pragma comment( lib, "cxcore.lib" )
#include "cv.h"
#include <stdio.h>
void main()
{
//矩陣元素爲三通道浮點數
CvMat* mat = cvCreateMat(3,3,CV_32FC3);
cvZero(mat);//將矩陣置0
//爲矩陣元素賦值
//獲得矩陣元素(0,0)的指針
float *p = (float*)cvPtr2D(mat, 0, 0);
//爲矩陣賦值
for(int i = 0; i < 9; i++)
{
//爲每個通道賦值
*p = (float)i*10;
p++;
*p = (float)i*10+1;
p++;
*p = (float)i*10+2;
p++;
}
//打印矩陣的值
p = (float*)cvPtr2D(mat, 0, 0);
for(i = 0; i < 9; i++)
{
printf("%2.1f,%2.1f,%2.1f/t",*p,*(p+1),*(p+2));
p+=3;
if((i+1) % 3 == 0)
printf("/n");
}
}
如果你不想使用指向數據的指針，而只是想獲得矩陣中的數據，你還可以使用cvGet*D函數系列。如下所示，該函數系列以返回值類型劃分有兩種，一種返回double類型數據，另一種返回CvScalar類型數據。
Get*D返回特殊的數組元素
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 );
arr輸入數組.
idx0元素下標第一個以0爲基準的成員
idx1元素下標第二個以0爲基準的成員
idx2元素下標第三個以0爲基準的成員
idx元素下標數組
函數cvGet*D 返回指定的數組元素。對於稀疏數組如果需要的節點不存在函數返回0 （不會創建新的節點）
GetReal*D返回單通道數組的指定元素
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 );
arr輸入數組，必須是單通道.
idx0元素下標的第一個成員，以0爲基準
idx1元素下標的第二個成員，以0爲基準
idx2元素下標的第三個成員，以0爲基準
idx
元素下標數組
函數cvGetReal*D 返回單通道數組的指定元素，如果數組是多通道的，就會產生運行時錯誤，而 cvGet*D 函數可以安全的被用於單通道和多通道數組，注意，該方法返回值類型是double類型的,這意味着，矩陣中如果保存的是int類型數據，不能用此係列方法。
#pragma comment(lib,"cxcore.lib")
#include"cv.h"
#include<stdio.h>
void main()
{
//矩陣元素爲1通道浮點型數據
CvMat*mat=cvCreateMat(3,3,CV_32FC1 );
cvZero(mat);//將矩陣置0
//爲矩陣元素賦值
//獲得矩陣元素(0,0)的指針
float *p=(float*)cvPtr2D(mat,0,0);
//爲矩陣賦值
for(int i=0;i<9;i++)
{
//爲每個通道賦值
*p=(float)i*10;
p++;
}
for(i=0;i<3;i++)
for(int j=0;j<3;j++)
{
printf("%lf/t",cvGetReal2D(mat,i,j));
}
}
另外，我們還有類似於cvGet*D()的方法爲矩陣元素賦值:cvSetReal*D()和cvSet*D()。
Set*D
修改指定的數組
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 );
arr
輸入數組
idx0
元素下標的第一個成員，以0爲基點
idx1
元素下標的第二個成員，以0爲基點
idx2
元素下標的第三個成員，以0爲基點
idx
元素下標數組
value
指派的值
函數 cvSet*D 指定新的值給指定的數組元素。對於稀疏矩陣如果指定節點不存在函數創建新的節點
SetReal*D
修改指定數組元素值
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 );
arr
輸入數組.
idx0
元素下標的第一個成員，以0爲基點
idx1
元素下標的第二個成員，以0爲基點
idx2
元素下標的第三個成員，以0爲基點
idx
元素下標數組
value
指派的值
函數 cvSetReal*D 分配新的值給單通道數組的指定元素，如果數組是多通道就會產生運行時錯誤。然而cvSet*D 可以安全的被用於多通道和單通道數組。
對於稀疏數組如果指定的節點不存在函數會創建該節點。
以下是一個例子：
#pragma comment(lib,"cxcore.lib")
#include"cv.h"
#include<stdio.h>
void main()
{
//矩陣元素爲三通道8位浮點數
CvMat *mat=cvCreateMat(3,3,CV_32FC3 );
cvZero(mat);//將矩陣置0
//爲矩陣元素賦值
for(int i = 0; i < 3; i++)
for(int j = 0; j < 3; j++)
cvSet2D( mat, i, j, cvScalar(i*10,j*10,i*j*10) );
for(i=0;i<3;i++)
for(int j=0;j<3;j++)
{
printf("%lf,%lf,%lf/t",cvGet2D( mat, i, j ).val[0],cvGet2D( mat, i, j ).val[1],cvGet2D( mat, i, j ).val[2]);
}
}
爲了方便起見，OpenCV還定義了兩個函數：cvmSet()和cvmGet(),這兩個函數用於單通道浮點型元素矩陣的存取。
例如，cvmSet(mat,2,2,0.5);就類似於cvSetReal2D(mat,2,2,0.5);
返回單通道浮點矩陣指定元素
double cvmGet( const CvMat* mat, int row, int col );
爲單通道浮點矩陣的指定元素賦值。
void cvmSet( CvMat* mat, int row, int col, double value );
