有很多函数有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);//乘加运算的始祖
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);//求原矩阵的逆矩阵,默认使用高斯消去法
行列式
double cvDet(const CvArr*mat);//计算方阵行列式,一定是单通道的
特征向量特征值
void cvEigenVV(CvArr* mat, CvArr*evects, CvArr* evals, doubleeps=0);//计算对称矩阵的特征值和特征向量,evects输出特征向量,evals输出特征值,eps雅可比方法停止参数
协方差
void cvCalcCovarMatrix(const CvArr**vects, int count, CvArr* cov_mat, CvArr* avg, intflags);//给定一组大小和类型相同的向量,向量的个数,计算标记,输出协方差正阵和每个向量的平均值矩阵
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);//两矩阵比较运算
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
空间转换
void cvFlip(const CvArr* src, CvArr*dst=NULL, intflip_mode=0);//图像绕x、y轴旋转。当用在一维数组上时并且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);
零的个数
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数组位置数值的中间
平均值标准差
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);//计算一个数组的各种范数
cvNormalize(const CvArr* src,CvArr* dst,double a=1.0,doubleb=0.0,int norm_type=CV_L2,const CvArr* mask=NULL);
cvReduce(const CvArr* src,CvArr* dst,int dim,intop=CV_REDUCE_SUM);//根据一定规则,把矩阵约简为向量
取得设置数组信息 得到指定行列
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);//
分布转换
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
在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 );