opencv访问数据元素

在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;
//获得矩阵元素的值
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;
//获得矩阵元素(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 );

正确的方式
前面介绍的一些读取和写入矩阵数据的方式，实际上，你可能很少会使用它们。因为，在大多数情况下，你需要使用最有效率的方式来访问矩阵中的数据。如果使用以上的函数界面来访问数据，效率比较低，你应该使用指针方式来直接访问矩阵中数据。特别是，如果你想遍历矩阵中所有元素时，就更需要这样做了。
在用指针直接访问矩阵元素时，就需要格外注意矩阵结构体中的step成员。该成员是以字节为单位的每行的长度。而矩阵结构体的cols或width就不适合此时使用，因为为了访问效率，矩阵中的内存分配上，是以每四个字节做为最小单位的。因此如果一个矩阵的宽度是三个字节，那么就会在宽度上分配四个字节，而此时每行最后一个字节会被忽略掉。所以我们用step则会准确地按行访问数据。
我们可以通过以下例子，看一下rows,cols,height,width,step的数据,你可以通过改变矩阵的元素类型定义，来查看step的改变：
#pragma comment(lib,"cxcore.lib")
#include"cv.h"
#include<stdio.h>
void main()
{
//矩阵元素为三通道8位浮点数
CvMat *mat=cvCreateMat(3,3,CV_32FC3 );
printf("rows=%d,cols=%d,height=%d,width=%d,step=%d/n",mat->rows,mat->cols,mat->height,mat->width,mat->step);

}
如果我们的矩阵存储的是浮点型（或整数类型）数据，此时矩阵中每个元素占4字节，则如果我们用float类型指针指向下一行时，我们实际上要用float类型指针挪动step/4的长度，因为float类型指针每挪动一个单位就是4个字节长度。
如果我们的矩阵存储的是double类型数据，此时矩阵中每个元素占8字节，则如果我们用double类型指针指向下一行时，我们实际上要用double类型指针挪动step/8的长度，因为double类型指针每挪动一个单位就是8个字节长度。
我们重新看一下CvMat类型的数据结构定义，其中，data就是数据部分，指向data的指针可以是多种数据类型的：
typedef struct CvMat {
int type;
int step;
int* refcount; // for internal use only
union {
uchar* ptr;
short* s;
int* i;
float* fl;
double* db;
} data;//数据部分
union {
int rows;
int height;
};
union {
int cols;
int width;
};
} CvMat;

我们可以通过为矩阵赋值，和读取的例子，查看怎样使用step:
#pragma comment(lib,"cxcore.lib")
#include"cv.h"
#include<stdio.h>
void main()
{
//矩阵元素为三通道8位浮点数
CvMat *mat=cvCreateMat(3,3,CV_32FC3 );
float *p;
int row,col;
for(row=0; row< mat->rows; row++)
{
p = mat->data.fl + row * (mat->step/4);
for(col = 0; col < mat->cols; col++)
{
*p = (float) row+col;
*(p+1) = (float) row+col+1;
*(p+2) =(float) row+col+2;
p+=3;
}
}

for(row = 0; row < mat->rows; row++)
{
p = mat->data.fl + row * (mat->step/4);
for(col = 0; col < mat->cols; col++)
{
printf("%f,%f,%f/t",*p,*(p+1),*(p+2));
p+=3;
}
printf("/n");
}
}

如果我们使用的指针类型为uchar*类型，则事情可能会简单一些，不用考虑step/4，step/8等类似情况,我们推荐用这种方式。如下例所示：

#pragma comment(lib,"cxcore.lib")
#include"cv.h"
#include<stdio.h>
void main()
{
//矩阵元素为三通道8位浮点数
CvMat *mat=cvCreateMat(3,3,CV_32FC3 );
float *p;
int row,col;
for(row=0; row< mat->rows; row++)
{
p = (float*)(mat->data.ptr + row * mat->step);
for(col = 0; col < mat->cols; col++)
{
*p = (float) row+col;
*(p+1) = (float) row+col+1;
*(p+2) =(float) row+col+2;
p+=3;
}
}

for(row = 0; row < mat->rows; row++)
{
p = (float*)(mat->data.ptr + row * mat->step);
for(col = 0; col < mat->cols; col++)
{
printf("%f,%f,%f/t",*p,*(p+1),*(p+2));
p+=3;
}
printf("/n");
}
}

最后要注意一下，我们在每行都要使用step重新计算一下指针的位置，这好象不如从首指针从头到尾一直指下去，如我们上一文章的例子一样

：
#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");
}
}

但是一定要注意了，这个例子其实是不对的！因为我们说过，分配矩阵内存空间时，是以四字节为最小单位的，这就很有可能有不到四个字节而取成四个字节的情况，所以，如果用矩阵首地址从头到尾指下去访问数据，就很有可能访问到不是数据的字节上去！这一点请务必牢记！！
综上所述，如果要直接访问矩阵中数据，请记住使用step的方案。


另一个需要知道的情况是，我们需要了解一个多维数组（矩阵）和一个一维，但是包含高维数据的数组之间的区别。假设，你有n个点(每个点有x,y,z坐标值) 需要保存到CvMat*中，你其实有四种方式可以使用，但这四种方式的存储形式不同。你可能使用一个二维矩阵，矩阵大小为n行3列，数据类型为 CV32FC1。你还可以使用一个二维矩阵，矩阵大小为3行n列，数据类型为CV32FC1；第三种可能性是，你使用一个一维矩阵，n行1列，数据类型为 CV32FC3；最后，你还可以使用1行三列，数据类型为CV32FC3.这几种方式，在内存分配上，有些是相同的，有些是不同的，如下所示：

n个点的集合(n=5)；
(x0 y0 z0) (x1 y1 z1) (x2 y2 z2) (x3 y3 z3) (x4 y4 z4)

n行1列时(数据类型CV32FC3)内存分配情况
x0 y0 z0 x1 y1 z1 x2 y2 z2 x3 y3 z3 x4 y4 z4

1行n列时(数据类型CV32FC3)内存分配情况
x0 y0 z0 x1 y1 z1 x2 y2 z2 x3 y3 z3 x4 y4 z4

n行3列时(数据类型CV32FC1)内存分配情况
x0 y0 z0 x1 y1 z1 x2 y2 z2 x3 y3 z3 x4 y4 z4

3行n列时(数据类型CV32FC1)内存分配情况
x0 x1 x2 x3 x4 y0 y1 y2 y3 y4 z0 z1 z2 z3 z4


我们可以看出，前三种的内存分配情况相同，但最后一种的内存分配不同。更复杂的是，如果有n维数组，每个数组的元素是c维(c可能是通道数)时。所以，多维数组(矩阵)和一个一维但包含多维数据的数组一般是不同的。

对于一个Rows行Cols列，通道数为Channels的矩阵，访问其中第row行,第col列,第channel通道的数据，可以使用如下公式：
数据地址偏移量=row*Cols*Channels+col*Channels+channel