当前位置：搜档网 › OpenCV常用的图像和矩阵操作总结

OpenCV常用的图像和矩阵操作总结

OpenCv常用图像和矩阵操作

学习资料 (2)

书籍 (2)

网站： (2)

本地安装目录 (2)

图像IplImage (3)

Structure IplImage (3)

图像的常用操作 (4)

图像载入函数 (4)

窗口定义函数 (4)

图像显示函数 (4)

图像保存函数 (4)

图像销毁函数 (5)

存取图像像素 (5)

简单的方法 (8)

麻烦的方法 (9)

恰当的方法 (12)

cvmSet(M,i,j,; Mb -> Mc

cvDiv(Ma, Mb, Mc); Mb -> Mc

cvAddS(Ma, cvScalar, Mc); Vb -> res

cvCrossProduct(&Va, &Vb, &Vc); 单矩阵操作: (13)

其他 (14)

Shell函数显示图片 (14)

IplImage 到cvMat的转换 (14)

学习资料

书籍

Learning OpenCV(影印版)

作者：Gary Bradski, Adrian Kaehler

出版社：东南大学出版社

学习OpenCV(中文版)

作者：Gary Bradski, Adrian Kaehler

译者：于仕琪刘瑞祯

出版社：清华大学出版社

OpenCV中文教程

作者：刘瑞祯于仕琪

网站：

本地安装目录

在安装目录\docs 下有各种学习资料

只用在本地安装目录下面就可以查询到大部分需要的信息，当然也可以直接百度，google

图像IplImage

Structure IplImage

OpenCv中图像的结构体为IplImage，位于头文件中，IplImage 结构体的定义如下：32F64F只有cvCreateImage可以创建交叉存取图像*/

int origin; /*图像原点位置：0表示顶-左结构,1表示底-左结构*/

int align; /* 图像行排列方式(4 or 8)，在OpenCV 被忽略，使用widthStep 代替*/ int width; /* 图像宽像素数*/

int height; /* 图像高像素数*/

struct _IplROI *roi; /* 图像感兴趣区域，当该值非空时，

只对该区域进行处理*/

struct _IplImage *maskROI; /* 在OpenCV中必须为NULL */

void *imageId; /* 同上*/

struct _IplTileInfo *tileInfo; /*同上*/

int imageSize; /* 图像数据大小(在交叉存取格式下

ImageSize=image->height*image->widthStep），单位字节*/

char *imageData; /* 指向排列的图像数据*/

int widthStep; /* 排列的图像行大小，以字节为单位*/

int BorderMode[4]; /* 边际结束模式, 在OpenCV 被忽略*/

int BorderConst[4]; /* 同上*/

char *imageDataOrigin; /* 指针指向一个不同的图像数据结构（不是必须排列的），是为了纠正图像内存分配准备的*/

} IplImage;}

IplImage;

参数widthStep包括相邻行的同列点之间的字节数。仅凭变量width是不能计算这个值的，因为为了处理过程更高效每行都会用固定的字节数来对齐；因此在第i行末和第i+1行开始处可能会有些冗于字节。参数imageData包含一个指向第一行图像数据的指针。如果图像中有些独立的平面(如当dataOrder = IPL_DATA_ORDER_PLANE)那么把它们作为单独的图像连续摆放，总行数为height和nChannels的乘积。但通常情况下，它们是交错的，使得行数等于高度，而且每一行都有序地包含交错的通道。

ROI-- 感兴趣的区域(ROI)，实际上它是另一个IPL/IPP 结构IplROI的实例。IplROI 包含xOffset，yOffset，height，width和coi成员变量，其中COI代表channel of interest(感兴趣的通道)。ROI的思想是：一旦设定ROI，通常作用于整幅图像的函数便会只对ROI 所表示的子图像进行操作。如果IplImage变量中设置了ROI，则所有的OpenCV函数就会使用该ROI变量。如果COI被设置成非0值，则对该图像的操作就只作用于被指定的通道上了。不幸的是，许多OpenCV函数都忽略参数COI。

图像的常用操作

图像载入函数

函数cvLoadImage载入指定图像文件，并返回指向该文件的IplImage指针。函数支持bmp、jpg、png、tiff等格式的图像。其函数原型如下：

IplImage* cvLoadImage( const char* filename, int iscolor);

其中，filename 是待载入图像的名称，包括图像的扩展名；iscolor是一个辅助参数项，可选正数、零和负数三种值，正数表示作为三通道图像载入，零表示该图像作为单通道图像，负数表示载入图像的通道数由图像文件自身决定。

窗口定义函数

函数cvNamedWindow定义一个窗口，用于显示图像。其函数原型如下：

int cvNamedWindow( const char* name, unsigned long flags );

其中，name是窗口名，flags是窗口属性指标值，可以选择CV_WINDOW_AUTOSIZE 和0两种值。CV_WINDOW_AUTOSIZE表示窗口尺寸与图像原始尺寸相同，0表示以固定的窗口尺寸显示图像。

图像显示函数

函数cvShowImage是在指定的窗口中显示图像，其函数原型如下：

void cvShowImage( const char* name, const CvArr* image );

其中，name是窗口名称，image是图像类型指针，一般是IplImage指针。

图像保存函数

函数cvSaveImage以指定的文件名保存IplImage类型的指针变量，其函数原型如下：int cvSaveImage( const char* filename, const CvArr* image );

其中，filename是图像保存路径和名称，image是IplImage指针变量。

Trick：

如果要保存一组图像到result文件夹,图像个数为n,保存名称按照一定的序号递增，假设为，，，，…, ，则

操作为：

char * f[30];

for(int i=0; i

{

sprintf(f,”result/imgTmp%”,i);

cvSaveImage(f,img);

}

借用sprintf函数即可以完成依次命名的功能。

图像销毁函数

函数cvReleaseImage销毁已定义的IplImage指针变量，释放占用内存空间。其函数原型如下：

void cvReleaseImage( IplImage** image );

其中，image为已定义的IplImage指针。

存取图像像素

包括获取像素值和对像素值赋值

直接获取

假设图像为IplImage * img,图像的depth= IPL_DEPTH_8U（每个像素用8 bits表示），获取像素坐标（x,y）的操作为

1. 灰度图像（单通道img->nChannels = 1）

对像素赋值：

((char*)(img->imageData + y*imge->widthStep))[x] = 255;

获取像素值：

int grayValue = ((char*)(img->imageData + y*imge->widthStep))[x];

2.彩色图像（单通道img->nChannels = 1）

对像素赋值：

((char*)(img->imageData + y*imge->widthStep))[3*x] = 255;

((char*)(img->imageData + y*imge->widthStep))[3*x+1] = 255;

((char*)(img->imageData + y*imge->widthStep))[3*x+2] = 255;

获取像素值：

uchar b = ((char*)(img->imageData + y*imge->widthStep))[x];

uchar g = ((char*)(img->imageData + y*imge->widthStep))[x];

uchar r = ((char*)(img->imageData + y*imge->widthStep))[x];

注意：

注意(char*)这个指针的强制转换是针对img->imageData + y*imge->widthStep的，也就是针对图像的行指针进行的转换，注意括弧的范围。

当image->depth为其他值时，则可能每个像素的数据类型需要进行(int*),(float*),(double*)等转换。

参数widthStep是相邻行的同列点之间的字节数。仅凭变量width是不能计算这个值的，因为为了处理过程更高效每行都会用固定的字节数来对齐；因此在第i行末和第i+1行开始处可能会有些冗于字节。一次在进行行切换时,一定要widthStep来进行内存的偏移,而不是用depth*width.

一般的情况下，假设有N-通道，类型为T 的图像：

I(x,y)c ~ ((T*)(img->imageData + img->widthStep*y))[x*N + c] y的位置

例子:

void saturate_sv( IplImage* img )

{

for( int y=0; y < img->height; y++ )

{

uchar* ptr = (uchar*) ( Img->imageData + y * img->widthStep );

for( int x=0; x < img->width; x++ )

{

ptr[3*x] = 255;

ptr[3*x+1] = 255;

ptr[3*x+2] = 255;

}

在以上程序中，我们用指针ptr指向第y行的起始位置。接着，我们从指针中析出饱和度和高度在x维的值。因为这是一个三通道图像，所以C通道在x行的位置是3*x+c。

该使用方法是受限的

uchar b,g,r;

b = img->imageData[img->widthStep * row + col * 3]

g = img->imageData[img->widthStep * row + col * 3 + 1];

r = img->imageData[img->widthStep * row + col * 3 + 2];

由于imageData指针始终是char*类型的，因此该方法只适用于8 bits/pixel的图像表示，其他的图像类型则需要进行指针转换。

●宏

可以使用宏CV_IMAGE_ELEM( image_header, elemtype, y, x_Nc )

I(x,y)c ~ CV_IMAGE_ELEM( img, T, y, x*N + c )，其中c为通道的序号，如彩色图像c=0，1，2

不过使用该宏是也要小心数据类型elemtype的问题。

也有针对各种图像（包括4 通道图像）和矩阵的函数（cvGet2D, cvSet2D），但是它们非常慢。

注：

该宏在每次调用时，都会重新计算指针的位置。这意味着，先查找数据区中第0个元素的位置，然后，根据参数中的行和列，计算所需要的元素的地址偏移量，然后将地址偏移量与第0个元素的地址相加，获得所需要的元素的地址。

所以，以上的方式虽然很容易使用，但是却不是获得元素的最好方式。特别是当你要顺序遍历整个图像中所有元素时，这种每次对地址的重复计算就更加显得不合理。

●cvGet2D()和cvSet2D()

可以通过cvGet2D()和cvSet2D()两个函数加上一个CvScalar结构体做到获取图像的像素点。

OpenCV中，CvScalar结构为：

typedef struct CvScalar

{

double val[4];

}

CvScalar;

4个double型变量，算法处理时不至于被强制类型转换而降低精度了。

再来看读写函数的定义：

cvGet2D 获得某个点的值, idx0=hight 行值, idx1=width 列值。

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

cvSet2D 给某个点赋值。

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

有上可见，cvGet2D的返回类型和cvSet2D中value的类型都是CvScalar，这样定义一个CvScalar变量再调用函数就OK了。

OpenCV中像素点读写例子：

格式为CV_(S|U|F)C.

例如: CV_8UC1 表示8位无符号单通道矩阵, CV_32SC2表示32位有符号双通道矩阵.

例: CvMat* M = cvCreateMat(4,4,CV_32FC1);

逐点赋值式初始化

CvMat* mat = cvCreateMat( 2, 2, CV_64FC1 );

cvZero( mat );

cvmSet( mat, 0, 0, 1 );

cvmSet( mat, 0, 1, 2 );

cvmSet( mat, 1, 0, 3 );

cvmSet( mat, 2, 2, 4 );

cvReleaseMat( &mat );

使用现有数组初始化

double a[] = { 1, 2, 3, 4,

5, 6, 7, 8,

9, 10, 11, 12 };

CvMat mat = cvMat( 3, 4, CV_64FC1, a );

简单的方法

从矩阵中得到一个元素的最简单的方法是利用宏CV_MAT_ELEM()。这个宏(参见例3-4)传入矩阵、待提取的元素的类型、行和列数4个参数，返回提取出的元素的值。

例3-4：利用CV_MAT_ELEM()宏存取矩阵

1.CvMat* mat = cvCreateMat( 5, 5, CV_32FC1 );

2.float element_3_2 = CV_MAT_ELEM( *mat, float, 3, 2 );

更进一步，还有一个与此宏类似的宏，叫CV_MAT_ELEM_PTR()。CV_MAT_ELEM_ PTR()(参见例3-5)传入矩阵、待返回元素的行和列号这3个参数，返回指向这个元素的指针。该宏和CV_MAT_ELEM()宏的最重要的区别是后者在指针解引用之前将其转化成指定的类型。如果需要同时读取数据和设置数据，可以直接调用CV_MAT_ELEM_PTR()。但在这种情况下，必须自己将指针转化成恰当的类型。

例3-5：利用宏CV_MAT_ELEM_PTR()为矩阵设置一个数值

1.CvMat* mat = cvCreateMat( 5, 5, CV_32FC1 );

2.float element_3_2 = ;

3.*( (float*)CV_MAT_ELEM_PTR( *mat, 3, 2 ) ) = element_3_2;

遗撼的是，这些宏在每次调用的时候都重新计算指针。这意味着要查找指向矩阵基本元素数据区的指针、计算目标数据在矩阵中的相对地址，然后将相对位置与基本位置相加。所以，即使这些宏容易使用，但也不是存取矩阵的最佳方法。在计划顺序访问矩阵中的所有元素时，这种方法的缺点尤为突出。

麻烦的方法

在"简单的方法"中讨论的两个宏仅仅适用于访问1维或2维的数组(回忆一下，1维的数组，或者称为"向量"实际只是一个n×1维矩阵)。OpenCV提供了处理多维数组的机制。事实上，OpenCV可以支持普通的N维的数组，这个N值可以取值为任意大的数。

为了访问普通矩阵中的数据，我们可以利用在例3-6和例3-7中列举的cvPtr*D和cvGet*D…等函数族。cvPtr*D家族包括cvPtr1D(), cvPtr2D(), cvPtr3D()和cvPtrND()…。这三个函数都可接收CvArr*类型的矩阵指针参数，紧随其后的参数是表示索引的整数值，最后是一个可选的参数，它表示输出值的类型。函数返回一个指向所需元素的指针。对于cvPtrND()来说，第二个参数是一个指向一个整型数组的指针，这个数组中包含索引的合适数字。后文会再次介绍此函数(在这之后的原型中，也会看到一些可选参数，必要时会有讲解)。

例3-6：指针访问矩阵结构

1.uchar* cvPtr1D(

2. const CvArr* arr,

3. int idx0,

4. int* type = NULL

5.);

7.uchar* cvPtr2D(

8. const CvArr* arr,

9. int idx0,

10.

11.

12.

13. int idx1,

14. int* type = NULL

15.);

16.

17.uchar* cvPtr3D(

18. const CvArr* arr,

19. int idx0,

20. int idx1,

21. int idx2,

22. int* type = NULL

23.);

24.uchar* cvPtrND(

25. const CvArr* arr,

26. int* idx,

27. int* type = NULL,

28. int create_node = 1,

29. unsigned* precalc_hashval = NULL

30.);

如果仅仅是读取数据，可用另一个函数族cvGet*D。如例3-7所示，该例与例3-6类似，但是返回矩阵元素的实际值。

例3-7：CvMat和IPlImage元素函数

1.double cvGetReal1D( const CvArr* arr, int idx0 );

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

3.double cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 )

;

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

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

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

8.CvScalar cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );

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

cvGet*D中有四个函数返回的是整型的，另外四个的返回值是CvScalar类型的。这意味着在使用这些函数的时候，会有很大的空间浪费。所以，只是在你认为用这些函数比较方便和高效率的时候才用它们，否则，最好用cvPtr*D。

用cvPtr*D()函数族还有另外一个原因，即可以用这些指针函数访问矩阵中的特定的点，然后由这个点出发，用指针的算术运算得到指向矩阵中的其他数据的指针。在多通道的矩阵中，务必记住一点：通道是连续的，例如，在一个3通道2维的表示红、绿、蓝(RGB)矩阵中。矩阵数据如下存储rgbrgbrgb . . .。所以，要将指向该数据类型的指针移动到下一通道，我们只需要将其增加1。如果想访问下一个"像素"或者元素集，我们只需要增加一定的偏移量，使其与通道数相等。

另一个需要知道的技巧是矩阵数组的step元素(参见例3-1和例3-3)，step是矩阵中行的长度，单位为字节。在那些结构中，仅靠cols或width是无法在矩阵的不同行之间移动指针的，出于效率的考虑，矩阵或图像的内存分配都是4字节的整数倍。所以，三个字节

宽度的矩阵将被分配4个字节，最后一个字节被忽略。因此，如果我们得到一个字节指针，该指针指向数据元素，那么我们可以用step和这个指针相加以使指针指向正好在我们的点的下一行元素。如果我们有一个整型或者浮点型的矩阵，对应的有整型和浮点型的指针指向数据区域，我们将让step/4与指针相加来移到下一行，对双精度型的，我们让step/8与指针相加(这里仅仅考虑了C将自动地将差值与我们添加的数据类型的字节数相

乘)。

例3-8中的cvSet*D和cvGet*D多少有些相似，它通过一次函数调用为一个矩阵或图像中的元素设置值，函数cvSetReal*D()和函数cvSet*D()可以用来设置矩阵或者图像中元素的数值。

例3-8：为CvMat或者IplImage元素设定值的函数

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

2.void cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );

3.void cvSetReal3D(

4. CvArr* arr,

5. int idx0,

6. int idx1,

7. int idx2,

8. double value

9.);

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

11.

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

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

14.void cvSet3D(

15. CvArr* arr,

16. int idx0,

17.

18. int idx1,

19. int idx2,

20. CvScalar value

21.);

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

为了方便，我们也可以使用cvmSet()和cvmGet()，这两个函数用于处理浮点型单通道矩阵，非常简单。

1.double cvmGet( const CvMat* mat, int row, int col )

2.void cvmSet( CvMat* mat, int row, int col, double value )

以下函数调用cvmSet()：

1.cvmSet( mat, 2, 2, );

等同于cvSetReal2D函数调用：

1.cvSetReal2D( mat, 2, 2, );

恰当的方法

从以上所有那些访问函数来看，你可能会想，没有必要再介绍了。实际上，这些set

和get函数很少派上用场。大多数时侯，计算机视觉是一种运算密集型的任务，因而你想尽量利用最有效的方法做事。毋庸置疑，通过这些函数接口是不可能做到十分高效的。相反地，应该定义自己的指针计算并且在矩阵中利用自己的方法。如果打算对数组中的每一个元素执行一些操作，使用自己的指针是尤为重要的(假设没有可以为你执行任务的OpenCV函数)。

要想直接访问矩阵，其实只需要知道一点，即数据是按光栅扫描顺序存储的，列("x")是变化最快的变量。通道是互相交错的，这意味着，对于一个多通道矩阵来说，它们变化的速度仍然比较快。例3-9显示了这一过程。

例3-9：累加一个三通道矩阵中的所有元素

1.float sum( const CvMat* mat ) {

3. float s = 0.0f;

4. for(int row=0; rowrows; row++ ) {

5. const float* ptr=(const float*)(mat-> + row * mat->step);

6. for( col=0; colcols; col++ ) {

7. s += *ptr++;

9. }

10. }

11. return( s );

12.}

计算指向矩阵的指针时，记住一点：矩阵的元素data是一个联合体。所以，对这个指针解引用的时候，必须指明结构体中的正确的元素以便得到正确的指针类型。然后，为了使指针产生正确的偏移，必须用矩阵的行数据长度(step)元素。我们以前曾提过，

行数据元素的是用字节来计算的。为了安全，指针最好用字节计算，然后分配恰当的类型，如浮点型。CvMat结构中为了兼容IplImage结构，有宽度和高度的概念，这个概念已经被最新的行和列取代。最后要注意，我们为每行都重新计算了ptr，而不是简单地从开头开始，尔后每次读的时候累加指针。这看起来好像很繁琐，但是因为CvMat 数据指针可以指向一个大型数组中的ROI，所以无法保证数据会逐行连续存取。

间接存取矩阵元素

cvmSet(M,i,j,; Mb -> Mc

cvDiv(Ma, Mb, Mc); Mb -> Mc

cvAddS(Ma, cvScalar, Mc); Vb -> res

cvCrossProduct(&Va, &Vb, &Vc); 单矩阵操作:

CvMat *Ma, *Mb;

cvTranspose(Ma, Mb);

其他

Shell函数显示图片

//用默认关联程序打开图片

ShellExecute(NULL,"open","Results\\",NULL,NULL,SW_SHOWNORMAL);

利用cvShowImage来显示图像，显示窗口是固定的，对窗口的操作很少。而利用shell函数调用相关程序（譬如windows图片查看器，画图板等），可以使用这些图片浏览工具的强大功能。

IplImage 到cvMat的转换

方式一、cvGetMat方式：

CvMat mathdr, *mat = cvGetMat( img, &mathdr );

方式二、cvConvert方式：

CvMat *mat = cvCreateMat( img->height, img->width, CV_64FC3 );

cvConvert( img, mat );

// #define cvConvert( src, dst ) cvConvertScale( (src), (dst), 1, 0 )

Opencv文件操作与数据存储

数据存储 OpenCV提供了一种机制来序列化(serialize)和去序列化(de-serialize)其各种数据类型，可以从磁盘中按YAML或XML格式读/写。在第4章中，我们将专门介绍存储和调用常见的对象IplImages的函数(cvSaveImage()和cvLoadImage())。此外，第4章将讨论读/写视频的特有函数：可以从文件或者摄影机中读取数据的函数cvGrabFrame()以及写操作函数cvCreateVideoWriter()和cvWriteFrame()。本小节将侧重于一般对象的永久存储：读/写矩阵、OpenCV结构、配置与日志文件。首先，我们从有效且简便的OpenCV矩阵的保存和读取功能函数开始。函数是cvSave()和cvLoad()。例3-15展示了如何保存和读取一个5×5的单位矩阵(对角线上是1，其余地方都是0)。例3-15：存储和读取CvMat 1.CvMat A= cvMat( 5, 5, CV_32F, the_matrix_data ); 2. 3.cvSave( "my_matrix.xml", &A ); 4.. . . 5.// to load it then in some other program use … 6.CvMat* A1= (CvMat*) cvLoad( "my_matrix.xml" ); CxCore参考手册中有整节内容都在讨论数据存储。首先要知道，在OpenCV中，一般的数据存储要先创建一个CvFileStorage结构(如例3-16)所示，该结构将内存对象存储在一个树形结构中。然后通过使用 CV_STORAGE_READ参数的cvOpenFileStorage()从磁盘读取数据，创建填充该结构，也可以通过使用 CV_STORAGE_WRITE的cvOpenFileStorage()创建并打开CvFileStorage写数据，而后使用适当的数据存储函数来填充它。在磁盘上，数据的存储格式为XML或者YAML。例3-16：CvFileStorage结构，数据通过CxCore数据存储函数访问 1.typedef struct CvFileStorage 2.{ 3.... // hidden fields 4.} CvFileStorage; CvFileStorage树内部的数据是一个层次化的数据集合，包括标量、CxCore对象(矩阵、序列和图)以及用户定义的对象。假如有一个配置文件或日志文件。配置文件告诉我们视频有多少帧(10)，画面大小(320×240)并且将应用一个3×3的色彩转换矩阵。例3-17展示了如何从磁盘中调出cfg.xml文件。例3-17：往磁盘上写一个配置文件cfg.xml 1.CvFileStorage* fs= cvOpenFileStorage( 2."cfg.xml", 3.0, 4.CV_STORAGE_WRITE 5.); 6.cvWriteInt( fs, "frame_count", 10 ); 7.cvStartWriteStruct( fs, "frame_size", CV_NODE_SEQ ); 8.cvWriteInt( fs, 0, 320 ); 9.cvWriteInt( fs, 0, 200 ); 10.cvEndWriteStruct(fs); 11.cvWrite( fs, "color_cvt_matrix", cmatrix );

OpenCV主要函数介绍

4.1 OpenCV主要函数介绍 1) cvLoadImage 从文件中读取图像 IplImage* cvLoadImage(const char* filename,int flags=CV_LOAD_IMAGE_COLOR ); 函数cvLoadImage从指定文件读入图像，返回读入图像的指针。其中filename是要被读入的文件的文件名；flags指定读入图像的颜色和深度。 2)cvSaveImage 保存图像到文件 int cvSaveImage( const char* filename, const CvArr* image ); 函数cvSaveImage保存图像到指定文件。其中filename保存文件名。image 要保存的图像。图像格式的的选择依赖于filename的扩展名，只有8位单通道或者3通道（通道顺序为'BGR' ）可以使用这个函数保存。 3)cvQueryFrame从摄像头或者文件中抓取并返回一帧 IplImage* cvQueryFrame( CvCapture* capture ); 函数cvQueryFrame从摄像头或者文件中抓取一帧，然后解压并返回这一帧。这个函数仅仅是函数cvGrabFrame和函数cvRetrieveFrame在一起调用的组合。返回的图像不可以被用户释放或者修改。其中capture视频获取结构。。 4)cvCaptureFromCAM 初始化摄像头 CvCapture* cvCaptureFromCAM( int index ); 函数cvCaptureFromCAM给从摄像头的视频流分配和初始化CvCapture结构。其中index要使用的摄像头索引。如果只有一个摄像头或者用哪个摄像头也无所谓，那使用参数-1应该便可以。 5）cvHaarDetectObjects 用来检测图像中的人脸区域 CV API(CvSeq*) cvHaarDetectObjects( const CvArr* image, CvHaarClassifierCascade* cascade, CvMemStorage* storage, double scale_factor CV_DEFAULT(1.1), int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0), CvSize min_size CV_DEFAULT(cvSize(0,0)), CvSize max_size CV_DEFAULT(cvSize(0,0))); 用于快速检测人脸区域，便于提取得到人脸数据。其中image 为被检图像，cascade为 haar分类器级联的内部标识形式，storage 为用来存储检测到的一

OPENCV函数

Opencv函数分配图像空间: IplImage*cvCreateImage(CvSize size,int depth,int channels); size:cvSize(width,height); depth:IPL_DEPTH_8U,IPL_DEPTH_8S,IPL_DEPTH_16U, IPL_DEPTH_16S,IPL_DEPTH_32S,IPL_DEPTH_32F, IPL_DEPTH_64F channels:1,2,3or4. 注意数据为交叉存取.彩色图像的数据编排为b0g0r0b1g1 r1... 举例: //分配一个单通道字节图像 IplImage*img1=cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,1); //分配一个三通道浮点图像 IplImage*img2=cvCreateImage(cvSize(640,480),IPL_DEPTH_32F,3); 释放图像空间: IplImage*img=cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,1); cvReleaseImage(&img); 复制图像: IplImage*img1=cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,1); IplImage*img2; img2=cvCloneImage(img1); 设定/获取兴趣区域: void cvSetImageROI(IplImage*image,CvRect rect); void cvResetImageROI(IplImage*image); vRect cvGetImageROI(const IplImage*image); 大部分OpenCV函数都支持ROI. 设定/获取兴趣通道: void cvSetImageCOI(IplImage*image,int coi);//0=all int cvGetImageCOI(const IplImage*image); 大部分OpenCV函数暂不支持COI.

OPenCV3.2中Mat对象常用函数属性总结

OPenCV3.2中Mat对象常用函数属性总结Mat对象是OpenCV2.0之后引进的图像数据结构，它能自动分配内存、不存在内存泄漏的问题，是面向对象的数据结构。分了两个部分，头部与数据部分。在使用Mat对象时，有以下四个要点需要注意： 1、输出图像的内存是自动分配的 2、使用OpenCV的C++接口，不需要考虑内存分配问题 3、赋值操作和拷贝构造函数只会复制头部分 4、使用clone与copyTo两个函数实现数据完全复制下面我们就具体介绍一下公共成员函数和公共属性。公共成员函数： 1、cv::Mat::Mat ( int rows, int cols, int type ) 参数： rows2D数组中的行数 cols2D数组中的列数。 type数组类型。使用CV_8UC1,…，CV_64FC4创建1 - 4通道矩阵，或CV_8UC(n)，…，CV_64FC(n)创建多通道(向上到CV_CN_MAX通道)矩阵。

2、cv::Mat::Mat ( Size size, int type ) 参数： size 2D数组大小:Size(cols, rows)。在Size()构造函数中，行数和列数以相反的顺序排列。 type 数组类型。使用CV_8UC1,…，CV_64FC4创建1 - 4通道矩阵，或CV_8UC(n)，…，CV_64FC(n)创建多通道(向上到CV_CN_MAX通道)矩阵。 3、cv::Mat::Mat ( int rows, int cols, int type, const Scalar & s ) 参数： rows2D数组中的行数。 cols 2D数组中的列数。 type数组类型。使用CV_8UC1,…，CV_64FC4创建1 - 4通道矩阵，或CV_8UC(n)，…，CV_64FC(n)创建多通道(向上到CV_CN_MAX通道)矩阵。s 初始化每个矩阵元素的可选值。在构建后将所有矩阵元素设置为特定值, 使用赋值运算符Mat::operator=(const Scalar& value) 。 4、cv::Mat::Mat ( Size size, int type,

OPENCV_Mat类存取方法(元素访问)

Opencv ----Mat类 ?cv::Mat ?depth/dims/channels/step/data/elemSize Mat矩阵中数据元素的地址计算公式： addr(M i0,i1,…i m-1) = M.data + M.step[0] * i0 + M.step[1] * i1+ … + M.step[m-1] * i m-1。其中m = M.dims 是指M的维度 i.data：Mat对象中的一个指针，指向内存中存放矩阵数据的一块内存(uchar* data). ii.row: 行；col：列；rows：行数；cols：列数。 iii.dims :Mat所代表的矩阵的维度，如3 * 4 的矩阵为2 维，3 * 4 * 5 的为3维. iv.channels：通道，矩阵中的每一个矩阵元素拥有的值的个数，比如说3 * 4 矩阵中一共12 个元素，如果每个元素有三个值，那么就说这个矩阵是3 通道的，即channels = 3。常见的是一张彩色图片有红、绿、蓝三个通道。但是opencv用imread（opencv读图的函数）读进来的图像，三通道存放顺序为B、 G、R。 v.depth：深度，即每一个像素的位数(bits)，在opencv的Mat.depth()中得到的是一个0 –6 的数字，分别代表不同的位数：enum { CV_8U=0, CV_8S=1, CV_16U=2, CV_16S=3, CV_32S=4, CV_32F=5, CV_64F=6 };可见0和1都代表8位，2和3都代表16位，4和5代表32位，6代表64位； vi.step：是一个数组，定义了矩阵的布局，具体见下面图片分析，另外注意step1

opencv矩阵操作学习资料

o p e n c v矩阵操作

通用矩阵乘法 void cvGEMM( const CvArr* src1, const CvArr* src2, double alpha, const CvArr* src3, double beta, CvArr* dst, int tABC=0 ); #define cvMatMulAdd( src1, src2, src3, dst ) cvGEMM( src1, src2, 1, src3, 1, dst, 0 ) #define cvMatMul( src1, src2, dst ) cvMatMulAdd( src1, src2, 0, dst ) src1 第一输入数组 src2 第二输入数组 src3 第三输入数组 (偏移量)，如果没有偏移量，可以为空（ NULL）。 dst 输出数组 tABC T操作标志，可以是 0 或者下面列举的值的组合: CV_GEMM_A_T - 转置 src1 CV_GEMM_B_T - 转置 src2 CV_GEMM_C_T - 转置 src3 例如, CV_GEMM_A_T+CV_GEMM_C_T 对应 alpha*src1T*src2 + beta*src3T 函数 cvGEMM 执行通用矩阵乘法: dst = alpha*op(src1)*op(src2) + beta*op(src3), 这里 op(X) 是 X 或者 XT

所有的矩阵应该有相同的数据类型和协调的矩阵大小。支持实数浮点矩阵或者复数浮点矩阵。 [编辑] Transform 对数组每一个元素执行矩阵变换 void cvTransform( const CvArr* src, CvArr* dst, const CvMat* transmat, const CvMat* shiftvec=NULL ); src 输入数组 dst 输出数组 transmat 变换矩阵 shiftvec 可选偏移向量函数 cvTransform 对数组 src 每一个元素执行矩阵变换并将结果存储到 dst: dst(I)=transmat*src(I) + shiftvec 或者 dst(I)k=sumj(transmat(k,j)*src(I)j) + shiftvec(k) N-通道数组 src 的每一个元素都被视为一个N元向量，使用一个M×N 的变换矩阵 transmat 和偏移向量 shiftvec 把它变换到一个 M-通道的数组 dst 的一个元素中。这里可以选择将偏移向量 shiftvec 嵌入到 transmat 中。这样

opencv矩阵操作

Opencv中函数的用法

1、cvLoadImage：将图像文件加载至内存； 2、cvNamedWindow：在屏幕上创建一个窗口； 3、cvShowImage：在一个已创建好的窗口中显示图像； 4、cvWaitKey：使程序暂停，等待用户触发一个按键操作； 5、cvReleaseImage：释放图像文件所分配的内存； 6、cvDestroyWindow：销毁显示图像文件的窗口； 7、cvCreateFileCapture：通过参数设置确定要读入的AVI文件； 8、cvQueryFrame：用来将下一帧视频文件载入内存； 9、cvReleaseCapture：释放CvCapture结构开辟的内存空间； 10、cvCreateTrackbar：创建一个滚动条； 11、cvSetCaptureProperty：设置CvCapture对象的各种属性； 12、cvGetCaptureProperty：查询CvCapture对象的各种属性； 13、cvGetSize：当前图像结构的大小； 14、cvSmooth：对图像进行平滑处理； 15、cvPyrDown：图像金字塔，降采样，图像缩小为原来四分之一； 16、cvCanny：Canny边缘检测； 17、cvCreateCameraCapture：从摄像设备中读入数据； 18、cvCreateVideoWriter：创建一个写入设备以便逐帧将视频流写入视频文件；搜索 19、cvWriteFrame：逐帧将视频流写入文件； 20、cvReleaseVideoWriter：释放CvVideoWriter结构开辟的内存空间； 21、CV_MAT_ELEM：从矩阵中得到一个元素； 22、cvAbs：计算数组中所有元素的绝对值；

OpenCv矩阵操作函数源代码

/* //////////////////////////////////////////////////////////////////// // // CvMat, CvMatND, CvSparceMat and IplImage support functions // (creation, deletion, copying, retrieving and setting elements etc.) // // */ #include "_cxcore.h" static struct { Cv_iplCreateImageHeader createHeader; Cv_iplAllocateImageData allocateData; Cv_iplDeallocate deallocate; Cv_iplCreateROI createROI; Cv_iplCloneImage cloneImage; } CvIPL; // Makes the library use native IPL image allocators CV_IMPL void cvSetIPLAllocators( Cv_iplCreateImageHeader createHeader, Cv_iplAllocateImageData allocateData, Cv_iplDeallocate deallocate, Cv_iplCreateROI createROI, Cv_iplCloneImage cloneImage ) { CV_FUNCNAME( "cvSetIPLAllocators" ); __BEGIN__; if( !createHeader || !allocateData || !deallocate || !createROI || !cloneImage ) { if( createHeader || allocateData || deallocate || createROI || cloneImage ) CV_ERROR( CV_StsBadArg, "Either all the pointers should be null or " "they all should be non-null" ); } CvIPL.createHeader = createHeader; CvIPL.allocateData = allocateData; CvIPL.deallocate = deallocate; CvIPL.createROI = createROI; CvIPL.cloneImage = cloneImage;

OPENCV的MAT类详解

类Mat导言 OpenCV c + + n 维稠密数组类类CV_EXPORTS Mat { public： / / … …很多的方法... ... /*!包括几位字段： -神奇的签名 -连续性标志 -深度（Note：应该是位深） -通道数 */ int flags;（Note ：目前还不知道flags做什么用的） //!数组的维数，> = 2 int dims ; //!行和列的数量或(-1，-1) 此时数组已超过2 维 int rows,cols; //!指向数据的指针 uchar *data ; //!指针的引用计数器； / / 阵列指向用户分配的数据时，当指针为NULL int * refcount ; / / 其他成员 ... }; Mat类表示一个n 维的密集数值单通道或多通道数组。它可以用于存储实数或复数值的向量和矩阵、灰度或彩色图像、体素、向量场、点云、张量、直方图（尽管较高维的直方图存储在SparseMat可能更好）。M 数组的数据布局是由阵列M.step[]定义的，使元素的地址（i0,。。。。i M.dims-1),其中0<= i k < M.size [k]，可以计算为： addr( Mi0 ;:::;i M.dims-1) = M.data+ M.step[ 0]*i0 + M.step[ 1] *i1+ .…+ M.step[ M:dims- 1] i M:dims- 1 2维的数组的情况下根据上述公式被减至： addr( M i,j)= M.data+ M.step[ 0]*i+ M.step[ 1] *j

请注意，M.step[i] > =M.step[i+1] （事实上，M.step[i] > =M.step[i+1]*M.size[i+1]）。这意味着2维矩阵是按行存储的，3 维矩阵是由平面存储，以此类推。M.step[M.dims-1] 是最小的而且总是等于元素大小M.elemSize()。因此，Mat中的数据布局完全兼容OpenCV 1.x 中CvMat、IplImage、CvMatND类型。它也和标准工具包和SDK，如Numpy（ndarray），Win32(独立设备位图)等主流的密集数组类型相兼容，也就是说，与任何使用步进（或步长）来计算像素位置的阵列相兼容。由于这种兼容性，使用户分配的数据创建Mat头以及用OpenCV函数实时处理该头成为可能。有很多不同的方法，创建一个Mat的对象。下面列出了最常见的选项：使用create（nrows,ncols,type）方法或类似的Mat（nrows,ncols,type [,fillValue]) 构造函数。一个新的指定了大小和类型的数组被分配。type和cvCreateMat 方法中的type 参数具有相同的含义。例如，CV_8UC1 是指一个8 位单通道阵列，CV_32FC2 指 2 通道 (复)浮点阵列，以此类推。 //创建一个用1+3j填充的7 x 7 复矩阵。 Mat M(7,7,CV_32FC2,Scalar(1,3)) ; / /现在将M转换为100 x 60的CV_8UC(15)的矩阵。 / / 旧内容将会被释放 M.create(100,60,CV_8UC(15)) ; 这一章导言中指出，当当前的数组与指定的数组的形状或类型create() 分配唯一的新数组时的形状或类型。创建多维数组： / / 创建100 x 100 x 100 8 位数组 int sz[] = {100, 100, 100}; Mat. bigCube (3,sz,CV_8U,Scalar::all(0)) ;它将维度数（= 1）传递给Mat的构造函数，但列数设置为1时，创建数组将是2 维的。因此，Mat::dims 始终是>=2的(该数组为空时，也可以是0）。使用的复制构造函数或赋值运算符可以是一个数组或右侧的表达式（请参阅下图）。正像在导言中指出的，数组赋值运算复杂度是O(1)因为当你需要它的时候，它仅复制头和增加引用计数。Mat::clone() 方法可用于获取全（深）的副本数组。为另一个数组的一部分构建头。它可以是单个行、单个列，几个行，几个列，矩形区域（代数中称为较小值）的数组或对角线。这种操作也是复杂度为O(1)，因为，新头引用相同的数据。实际上，您可以使用此特性修改该数组的一部分例如： / /第5行，乘以3，加到第3 行， M.row(3) = M.row(3) + M.row (5) * 3 ; / / 现在将第7列复制到第1列

OpenCV读取与操作摄像头

OpenCV读取摄像头 OpenCV可以读取摄像头的图像，主要是流媒体，读取的类是cv::VideoCapture，输入参数为摄像头参数：当使用USB摄像头时，输入0,1,2…等对应参数当使用网络摄像头时，直接输入url地址。 OpenCV设置属性使用cv::VieoCapture时，先生成一个实例，然后设置属性，此时有一点要注意，当读取的图片原本只有400*300时，设置高宽800*600是无效的（即超过输入的尺寸设置是无效的），然后不断使用>>读取，读取就显示。 cv::VideoCapture capture; if(!capture.open(0)) { qDebug() << __FILE__ << __LINE__ << "Failed to open camera: 0"; }else{ qDebug() << __FILE__ << __LINE__ << "Succeed to open camera: 0"; } while(true) { cv::Mat mat; capture >> mat; int keyValue = cv::waitKey(1) } 同时经过测试发现，此次打开的是上次的设置结果，所以可以判断opencv 实际是直接操作了设备的相关属性，所以调整的属性需要摄像头设备支持（USB 摄像头），并不是单纯的认为拿到图片后opencv自己对图像进行处理。 Demo函数源码 void OpenCVManager::testCamera() { cv::VideoCapture capture; // 插入USB摄像头默认为0

opencv应用函数

目录 1 一、简介 1.1 1、OpenCV的特点 1.1.1 （1）总体描述 1.1.2 （2）功能 1.1.3 （3）OpenCV模块 1.2 2、有用的学习资源 1.2.1 （1）参考手册： 1.2.2 （2）网络资源： 1.2.3 （3）书籍： 1.2.4 （4）视频处理例程(在/samples/c/): 1.2.5 （5）图像处理例程(在/samples/c/): 1.3 3、OpenCV 命名规则 1.3.1 （1）函数名: 1.3.2 （2）矩阵数据类型: 1.3.3 （3）图像数据类型: 1.3.4 （4）头文件: 1.4 4、编译建议 1.4.1 （1）Linux: 1.4.2 （2）Windows: 1.5 5、C例程 2 二、GUI 指令 2.1 1、窗口管理 2.1.1 （1）创建和定位一个新窗口: 2.1.2 （2）载入图像: 2.1.3 （3）显示图像: 2.1.4 （4）关闭窗口: 2.1.5 （5）改变窗口大小: 2.2 2、输入处理 2.2.1 （1）处理鼠标事件: 2.2.2 （2）处理键盘事件: 2.2.3 （3）处理滑动条事件: 3 三、OpenCV的基本数据结构 3.1 1、图像数据结构 3.1.1 （1）IPL 图像: 3.2 2、矩阵与向量 3.2.1 （1）矩阵: 3.2.2 （2）一般矩阵: 3.2.3 （3）标量: 3.3 3、其它结构类型 3.3.1 （1）点:

3.3.2 （2）矩形框大小（以像素为精度）: 3.3.3 （3）矩形框的偏置和大小: 4 四、图像处理 4.1 1、图像的内存分配与释放 4.1.1 （1）分配内存给一幅新图像: 4.1.2 （2）释放图像: 4.1.3 （3）复制图像: 4.1.4 （4）设置/获取感兴趣区域ROI: 4.1.5 （5）设置/获取感兴趣通道COI: 4.2 2、图像读写 4.2.1 （1）从文件中读入图像: 4.2.2 （2）保存图像: 4.3 3、访问图像像素 4.3.1 （1）假设你要访问第k通道、第i行、第j列的像素。 4.3.2 （2）间接访问: (通用，但效率低，可访问任意格式的图像) 4.3.3 （3）直接访问: (效率高，但容易出错) 4.3.4 （4）基于指针的直接访问: (简单高效) 4.3.5 （5）基于c++ wrapper 的直接访问: （更简单高效） 4.4 4、图像转换 4.4.1 （1）字节型图像的灰度-彩色转换: 4.4.2 （2）彩色图像->灰度图像: 4.4.3 （3）不同彩色空间之间的转换: 4.5 5、绘图指令 4.5.1 （1）绘制矩形: 4.5.2 （2）绘制圆形: 4.5.3 （3）绘制线段: 4.5.4 （4）绘制一组线段: 4.5.5 （5）绘制一组填充颜色的多边形: 4.5.6 （6）文本标注: 5 五、矩阵处理 5.1 1、矩阵的内存分配与释放 5.1.1 （1）总体上: 5.1.2 （2）为新矩阵分配内存: 5.1.3 （3）释放矩阵内存: 5.1.4 （4）复制矩阵: 5.1.5 （5）初始化矩阵: 5.1.6 （6）初始化矩阵为单位矩阵: 5.2 2、访问矩阵元素 5.2.1 （1）假设需要访问一个2D浮点型矩阵的第（i, j）个单元. 5.2.2 （2）间接访问: 5.2.3 （3）直接访问（假设矩阵数据按4字节行对齐）: 5.2.4 （4）直接访问（当数据的行对齐可能存在间隙时possible alignment gaps）:

OpenCV中对数组(矩阵)的操作的函数表

ALL ABOUT MY CODE AND MY LITTLE EMOTIONS 创建博客登录网易博客发现小组风格登录新版LOFTER，送IMAX电影票 >加关注

OpenCV - Operations on Arrays 对数组(矩阵)的一些操作Function (函数名)Use (函数用处) Author : Ggicci 转载请注明出处!split 多通道矩阵分解成多个单通道矩阵merge 多个单通道矩阵合成一个多通道矩阵mixChannels 矩阵间通道拷贝，如Rgba[]到Rgb[]和Alpha[]sort, sortIdx 为矩阵的每行或每列元素排序setIdentity 设置单元矩阵completeSymm 矩阵上下三角拷贝inRange 检查元素的取值范围是否在另两个矩阵的元素取值之间，返回验证矩阵checkRange 检查矩阵的每个元素的取值是否在最小值与最大值之间，返回验证结果bool sum 求矩阵的元素和mean 求均值meanStdDev 均值和标准差countNonZero 统计非零值个数cartToPolar, polarToCart 笛卡尔坐标与极坐标之间的转换flip 矩阵翻转transpose 矩阵转置，比较 Mat::t() A T trace 矩阵的迹determinant 行列式 |A|, det(A)eigen 矩阵的特征值和特征向量invert 矩阵的逆或者伪逆，比较 Mat::inv()magnitude 向量长度计算 dst(I) = sqrt(x(I)2 + y(I)2)Mahalanobis Mahalanobis距离计算phase 相位计算，即两个向量之间的夹角norm 求范数，1-范数、2-范数、无穷范数normalize 标准化mulTransposed 矩阵和它自己的转置相乘 A T * A, dst = scale(src - delta)T (src - delta)convertScaleAbs 先缩放元素再取绝对值，最后转换格式为8bit型calcCovarMatrix 计算协方差阵solve 求解1个或多个线性系统或者求解最小平方问题(least-squares problem)solveCubic 求解三次方程的根solvePoly 求解多项式的实根和重根dct, idct 正、逆离散余弦变换，idct同dct(src, dst, flags | DCT_INVERSE)dft, idft 正、逆离散傅立叶变换, idft同dft(src, dst, flags | DTF_INVERSE)LUT 查表变换getOptimalDFTSize 返回一个优化过的DFT大小mulSpecturms 两个傅立叶频谱间逐元素的乘法您可能也喜欢： OpenCV函数的参数用法（1 mask） 2012.07.21OpenCV中的结构体、类与Emgu.CV的2012.07.09

OpenCV矩阵操作

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,

opencv二值化函数cvThreshold

opencv二值化函数cvThreshold OpenCV 2009-03-26 16:00:07 阅读4570 评论5 字号：大中小订阅对图像二值化函数cvThreshold的理解 Threshold 对数组元素进行固定阈值操作 void cvThreshold( const CvArr* src, CvArr* dst, double threshold, double max_value, int threshold_type ); src 原始数组 (单通道 , 8-bit of 32-bit 浮点数). dst 输出数组，必须与 src 的类型一致，或者为 8-bit. threshold 阈值 max_value 使用 CV_THRESH_BINARY 和 CV_THRESH_BINARY_INV 的最大值. threshold_type 阈值类型 (见讨论) 函数 cvThreshold 对单通道数组应用固定阈值操作。该函数的典型应用是对灰度图像进行阈值操作得到二值图像。(cvCmpS 也可以达到此目的) 或者是去掉噪声，例如过滤很小或很大象素值的图像点。本函数支持的对图像取阈值的方法由 threshold_type 确定: threshold_type=CV_THRESH_BINARY: dst(x,y) = max_value, if src(x,y)>threshold 0, otherwise. threshold_type=CV_THRESH_BINARY_INV: dst(x,y) = 0, if src(x,y)>threshold; dst(x,y) = max_value, otherwise. threshold_type=CV_THRESH_TRUNC: dst(x,y) = threshold, if src(x,y)>threshold; dst(x,y) = src(x,y), otherwise. threshold_type=CV_THRESH_TOZERO: dst(x,y) = src(x,y), if (x,y)>threshold ; dst(x,y) = 0, otherwise.

OpenCV学习笔记

第一章概述 OpenCV 是有Intel公司资助的开源计算机视觉库，它由一系列C函数和少量C++类构成，实现图像处理和计算机视觉方面的很多通用算法。 1、OpenCV的特征（1）开源计算机视觉库采用C/C++编写（2）使用目的是开发实时的应用程序（3）独立于操作系统、硬件和图形管理器（4）具有通用的图像/视频载入、保存和获取模块（5）具有底层和高层的应用开发包 2、OpenCV的功能（1）对图像数据的操作，包括分配、释放、复制、设置和转换数据（2）对图像和视频的输入输出，指文件和摄像头作为输入，图像和视频文件作为输出（3）具有对矩阵和向量的操作及线性代数的算法程序，包括矩阵积、解方程、特征值以及奇异值（4）可对各种动态数据结构，如列表、队列、集合、树和图等进行操作（5）具有基本的数字图像处理能力，如可以进行滤波、边缘检测、角点检测、采样于差值、色彩转换、形态操作、直方图和图像金字塔等操作（6）对各种结构进行分析，包括连接部件分析、轮廓处理、距离变换、各种距的计算、模板匹配、Hough变换、多边行逼近、直线拟合、椭圆拟合、和Delaunay三角划分等（7）对摄像头的定标，包括发现与跟踪定标模式、定标、基本矩阵估计、齐次矩阵估计和立体对应（8）对运动的分析，如对光流、运动分割和跟踪的分析（9）对目标的识别，如可采用特征法和隐马尔科夫模型（HMM）法（10）具有基本的GUI功能，包括图像与视频显示、键盘和鼠标事件处理及滚动条等（11）课对图像标注，如对线，二次曲线和多边行进行标注 3.OpenCV模块 ?cv –核心函数库 ?cvaux –辅助函数库 ?cxcore –数据结构与线性代数库 ?highgui – GUI函数库 ?ml –机器学习函数库