OpenCV的函数简要说明（不断收集扩充中）

野性酷女 2022-05-15 03:11 201阅读 0赞

## 机器学习函数 ##

关于机器学习的函数，很多在OpenCV的中文官网上有解释，这里不再重复贴出，链接如下，

[http://wiki.opencv.org.cn/index.php/机器学习中文参考手册][http_wiki.opencv.org.cn_index.php]

## CvSeq内存管理函数简要说明 ##

(1)CreatSeq

> 功能:
> 
> 函数cvCreatSeq创建一序列并返回指向该序列的指针.
> 
> 格式
> 
> CvSeq\* cvCreatSeq(int seq\_flags,int header\_size, int elem\_size,CvMemStorage\* storage);
> 
> 参数:
> 
> seq\_flags 序列的符号标志.如果序列不被传递给任何需使用特定序列的函数,则将他设为0,否则从预定义的序列类型中选择一合适类型.
> 
> header\_size 序列头部的大小,必须大于或等于sizeof(CvSeq).如果指定了序列类型或序列扩展名,则次类型必须适合基类的头部大小.
> 
> elem\_size 元素的大小,以字节为单位.此大小必须与序列类型一致.例如,对于一个店序列,应当指定元素类型为CV\_SEQ\_ELTYPE\_POINT,参数elem\_size必须等于sizeof(CvPoint)
> 
> storage 序列的位置.
> 
> 说明
> 
> 函数在存储块中分配序列的头部作为一个连续块,并将结构CvSeq的flags,elem\_size,header\_size和storage各域的值设置为从此函数传递过来的值,设置delta\_elems为默认(可通过函数cvSetSeqBlockSize对其重新赋值),清空其他的头部域,包括前sizeof(CvSeq)字节空间.

(2)SetSeqBlockSize

> 功能:
> 
> 函数cvSetSeqBlockSize设置序列块的大小
> 
> 格式
> 
> void cvSetSeqBlockSize(CvSeq\* seq,int delta\_emems);
> 
> 参数
> 
> seq 序列
> 
> delta\_elems 满足元素所需块的大小
> 
> 说明
> 
> 函数cvSetSeqBlockSize将对内存分配的粒度产生影响,当序列缓冲区中的空间消耗完时,函数为delta\_elems个序列元素分配空间.如果新分配的空间与之前分配的空间相邻,则两块合并;否则,创建一个新的序列块.因此,参数值delta\_elems越大,序列中出现碎片的可能性就越小;不过内存中更多的空间被浪费.当序列被创建后,参数delta\_elems的大小被设置为默认大小(1K).之后,可随时调用此函数,并影响内存的分配.次函数可修改传递过来的参数值,以满足内存块的大小限制.

(3)SeqPush

> 功能
> 
> 函数cvSeqPush添加元素到序列的尾部
> 
> 格式
> 
> char\* cvSeqPush(CvSeq\* seq,void\* element = NULL);
> 
> 参数
> 
> seq 块
> 
> element 添加的元素
> 
> 说明:
> 
> 函数cvSeqPush在序列块的尾部添加一元素并返回指向该元素的指针.如果输入参数为NULL,则函数仅分配一空间,留给下一个元素使用.下列代码说明了如何使用该函数去分配一个空间.
> 
>  
> 
>     CvMemStorage* storage = cvCreateMemStorage(0);
>         CvSeq* seq = cvCreateSeq(CV_32SC1,sizeof(CvSeq),sizeof(int),storage);
>         int i;
>         for (int i=0;i<100;i++)
>         {
>             int* added = (int*)cvSeqPush(seq,&i);
>             printf("%d is added",*added);
>         }
>     
>         cvReleaseMemStorage(&storage);
> 
> 函数cvSeqPush的时间复杂度为O(1).如果需要分配并使用的空间较大,则可使用分配较快的函数(见cvStartWriterSeq和相关函数)

(4)SeqPop

> 功能:
> 
> 函数cvSeqPop删除序列的尾部元素
> 
> 格式
> 
> void cvSeqPop(CvSeq\* seq,void\* element =NULL);
> 
> 参数:
> 
> seq 序列
> 
> element 可选参数.如果改指针不为空,则赋值被删除元素到指针所指位置.
> 
> 说明:
> 
> 函数cvSeqPop从序列中删除一元素.如果序列已经为空,则报告错误.函数的事件复杂度为O(1).

(5)SeqPushFront

> 功能
> 
> 函数cvSeqPushFront在序列头部添加元素
> 
> 格式
> 
> char\* cvSeqPushfront(CvSeq\* seq,void\* element = NULL);
> 
> 参数:
> 
> seq 序列
> 
> element 添加的元素.
> 
> 说明
> 
> 函数cvSeqPushFront类似于cvSeqPush,不过是在序列头部添加元素.其时间复杂度为O(1).

(6)SeqPopFront

> 功能:
> 
> 函数cvSeqPopFront删除序列的头部元素
> 
> 格式
> 
> void cvSeqPop(CvSeq\* seq,void\* element =NULL);
> 
> 参数:
> 
> seq 序列
> 
> element 可选参数.如果改指针不为空,则赋值被删除元素到指针所指位置.
> 
> 说明:
> 
> 函数cvSeqPop从序列中删除一元素.如果序列已经为空,则报告错误.函数的事件复杂度为O(1).

(7)SeqPushMulti

> 功能
> 
> 函数cvSeqPushMulti在序列头部或尾部添加多个元素
> 
> 格式
> 
> void cvSeqPushMulti(CvSeq\* seq,void\* elements,int count , int in\_font = 0);
> 
> 参数
> 
> seq 序列
> 
> elements 待添加的元素
> 
> count 添加的元素个数
> 
> in\_front 标识在头部haishi在尾部添加元素.为下列值之一:
> 
>           CV_BACK(=0)  在序列的尾部添加元素
>        
>            CV_FRONT(≠ 0) 在序列的头部添加元素
> 
> 说明
> 
> 带添加元素按输入数组中的顺序被添加到序列中,而且他们可以添加到不同的序列中.

(8)SeqPopMulti

> 功能
> 
> 函数cvSeqPopMulti删除多个序列头部或尾部的元素.
> 
> 格式
> 
>  
> 
> void cvSeqPopMulti(CvSeq\* seq,void\* elements,int count , int in\_font = 0);
> 
> 参数
> 
> seq 序列
> 
> elements 待删除的元素
> 
> count 待删除的元素个数
> 
> in\_front 标识在头部haishi在尾部添加元素.为下列值之一:
> 
>           CV_BACK(=0)  在序列的尾部添加元素
>        
>            CV_FRONT(≠ 0) 在序列的头部添加元素
> 
> 说明
> 
> 如果待删除元素的个数超过序列中的元素总数,则函数将删除所有元素.

(9)SeqInsert

> 功能
> 
> 函数cvSeqInsert在序列中插入元素
> 
> 格式
> 
> char\* cvSeqInsert(CvSeq\* seq, int before\_index, void\* element = NULL);
> 
> 参数
> 
> seq 序列
> 
> before\_index 元素插入的位置(即索引).如果插入的位置在0(允许的参数最小值)之前,则该函数等同于函数cvSeqPushFront;如果是在seq\_total(允许的参数最大值)之后,则函数等同于cvSeqPush
> 
> element 待插入的元素
> 
> 说明
> 
> 函数cvSeqIndsert移动从被插入位置到序列尾部的所有元素,如果指针element不为NULL,则将element中的元素复制到指定的位置.函数返回指向被插入元素的指针.

(10)SeqRemove

> 功能
> 
> 函数cvSeqRemove删除索引指定的元素
> 
> 格式
> 
> void cvSeqRemove(CvSeq\* seq,int index);
> 
> 参数
> 
> seq 序列
> 
> index 被删除的元素索引
> 
> 说明
> 
> 如果索引超出了序列的范围,或函数企图从空序列中删除元素,则报告错误.函数通过移动序列中的元素来删除指定的元素

(11)ClearSeq

> 功能
> 
> 函数cvClearSeq删除序列中的所有元素
> 
> 格式
> 
> void cvClearSeq(CvSeq\* seq);
> 
> 参数
> 
> seq 序列
> 
> 说明
> 
> 函数不会将不在使用的内存返回到存储器中,当新元素添加到序列中时,可重新使用该内存.函数的时间复杂度为O(1).

(12)GetSeqElem

> 功能
> 
> 函数cvGetSeqElem返回索引指定的元素指针
> 
> 格式
> 
> char\* cvGetSeqElem(const CvSeq\* seq,int index);
> 
> \#define CV\_GET\_SEQ\_ELEM(TYPE,seq,index)\\
> 
>            (TYPE* )cvGetSeqElem((CvSeq*)(Seq),(index))
> 
> 参数
> 
> seq 序列
> 
> index 索引
> 
> 说明
> 
> 函数cvGetSeqElem查找序列中由索引指定的元素,并返回指向该元素的指针.如果元素不存在则返回0.函数索引支持负数,即-1代表序列的最后一个元素,-2代表倒数第二个元素,等等.如果序列只包含一个块,或者所需元素在第一个块中,那么应当使用宏CV\_GET\_SEQ\_ELEM(elemType,seq,index),宏中参数elemType是序列中元素的类型(如CvPoint),参数seq表示序列,参数index代表所需元素的索引.该宏首先核查所需元素是否属于第一个块,若是则返回该元素;否则,该宏调用主函数cvGetSeqElem.如果索引为负数,则总调用函数cvGetSeqElem.函数的时间复杂度为O(1),并假设块的大小比元素的数量小.

(13)SeqElemIdx

> 功能
> 
> 函数cvSeqElemIdx返回序列中元素的索引
> 
> 格式
> 
> int cvSeqElemIdx(const CvSeq\* seq,const void\* element, CvSeqBlock\*\* blodk=NULL);
> 
> 参数
> 
> seq序列
> 
> element 指向序列中元素的指针
> 
> block 可选参数,如果不为空,则存放包含所指元素的块的地址
> 
> 说明
> 
> 函数cvSeqElemIdx放回元素的索引,如果该元素不在此序列中,则返回一个负数

(14)CvtSeqToArray

> 功能
> 
> 函数cvCvtSeqToArray复制序列中的元素到一个连续的内存块中
> 
> 格式
> 
> void\* cvCvtSeqToArray(const CvSeq\* seq, void\* elements, CvSlice slice= CV\_WHILE\_SEQ);
> 
> 参数
> 
> seq 序列
> 
> elements 指向目的的数组(存放已复制的元素)的指针,指针指向的空间必须足够大.
> 
> slice 复制序列部分到数组中.
> 
> 说明
> 
> 函数cvCvtSeqToArray复制整个或部分序列到指定的缓冲区中,并返回指向该缓冲区的指针.
> 
> 下列说明如何将序列中的点集提取出来

CvMemStorage* stor;
        CvSeq* cont;
        CvPoint* PointArray;
        CvPoint2D32f* PointArray2D32f;
        float temp;
    
        //创建动态结构和序列
        stor = cvCreateMemStorage(0);
        cont = cvCreateSeq(CV_SEQ_ELTYPE_POINT,sizeof(CvSeq),sizeof(CvPoint),stor);
        //寻找所有轮廓并放置在序列中
      cvFindContours(src,stor,&cont,sizeof(CvContour),CV_RETR_LIST,CV_CHAIN_APPROX_NONE,cvPoint(0,0));
        for (;cont;cont=cont->h_next)
        {
            int i;
            int count = cont->total;
            CvPoint center;
            CvSize size;
            PointArray = (CvPoint*) malloc(count* sizeof(CvPoint));
            PointArray2D32f = (CvPoint2D32f*)malloc(count* sizeof(CvPoint2D32f));
            //获取点内容
            cvCvtSeqToArray(cont,PointArray,CV_WHOLE_SEQ);
            //把点放置到集合中
            for (i=0;i<count ;i++)
            {
                PointArray2D32f[i].x =(float)PointArray[i].x;
                PointArray2D32f[i].y = (float)PointArray[i].y;
            }
            //释放内存
            free(PointArray);
            free(PointArray2D32f);
            //free(box);
        }

(15)MakeSeqHead而ForArray

> 功能
> 
> 函数cvMakeSeqHeaderForArray构建序列
> 
> 格式
> 
>     cvMakeSeqHeaderForArray( int seq_type, int header_size,                                   int elem_size, void* elements, int total,   
>            CvSeq* seq, CvSeqBlock* block );
> 
> 参数
> 
> seq\_type 序列的类型
> 
> header\_size 序列的头部大小.该值必须大于等于数组的大小
> 
> elem\_size 元素的大小
> 
> elements 星辰该序列的元素
> 
> total 序列中元素的总数.此值必须等于elements中元素的个数
> 
> seq 指向被用做序列头部分局部变量
> 
> block 指向局部变量的指针
> 
> 说明
> 
> 函数cvMakeSeqHeaderForArray初始化序列的头部.序列头和序列块由用户分配.该函数不复制数据.创建的序列只包含一个块及一个NULL指针,因此用户可以读取指针.但若试图将元素添加到序列中,则多数会引发错误.

(16)SeqSlice

> 功能
> 
> 函数cvSeqSlice为序列碎皮建立独立的头
> 
> 格式
> 
> CvSeq\* cvSeqSlice(const CvSeq\* seq,CvSlice slice, CvMemStorage\* storage = NULL, int copy\_data = 0);
> 
> 参数
> 
> seq 序列
> 
> slice 部分序列块
> 
> storage 存放新序列和复制数据(如果需要)的目的的存储空间.如果为NULL,则此函数使用存储输入序列的存储空间
> 
> copy\_data 标志是否要复制元素,如果不为0,则需要复制;否则,则不需要复制
> 
> 说明
> 
> 函数cvSeqSlice创建一序列,该序列为输入序列中特定的一部分(slice).新序列或者与原序列共享元素或者拥有自己的一个备份.因此,如果需要处理某部分序列,而函数却没有slice参数,则可使用次函数获取该序列

(17)cloneSeq

> 功能
> 
> 函数cvCloneSeq创建序列的一个备份
> 
> 格式
> 
> CvSeq\* cvCloneSeq(const CvSeq\* seq,CvMemStorage\* storage= NULL);
> 
> 参数
> 
> seq 序列
> 
> storage 存放新序列头部分和复制数据(如果需要)的目的存储空间.如果为NULL,则此函数使用存储输入序列的存储空间
> 
> 说明
> 
> 函数cvCloneSeq创建输入序列的一个完全备份.调用函数cvCloneSeq(seq,storage)等同于调用函数cvSeqSlice(seq,CV\_WHolE\_SEQ,storage,1);

(18)SeqRemoveSlice

> 功能
> 
> 函数cvSeqRemoveSlice删除序列中的slice部分
> 
> 格式
> 
> void cvSeqRemoveSlice(CvSeq\* seq,CvSlice slice);
> 
> 参数
> 
> seq 序列
> 
> slice 序列中被删除的部分

(19)SeqInsertSlice

> 功能
> 
> 函数cvSeqInsertSlice在序列中插入一个数组
> 
> 格式
> 
> void cvSeqInsertSlice(CvSeq\* seq,int before\_index,const CvArr\* from\_arr);
> 
> seq 序列
> 
> before\_index 插入位置
> 
> from\_arr 获取元素的数组
> 
> 说明
> 
> 函数cvSeqInsertSlice在指定位置插入来自数组from\_arr中的所有元素.数组from\_arr可以是一个矩阵,也可以是另外一个序列

(20)SeqInvert

> 功能
> 
> 函数cvSeqInvert对序列中的元素进行逆序操作.
> 
> 格式
> 
> void cvSeqInvert(CvSeq\* seq);
> 
> 参数
> 
> seq 序列
> 
> 说明
> 
> 函数cvSeqInvert对序列进行逆序操作,也就是说,使第一个元素成为最后一个,最后一个元素成为第一个

(21)SeqSort

> 功能
> 
> 函数cvSeqSort使用特定的比较函数对序列中的元素进行排序
> 
> 在使用特定的比较函数应先进行如下声明
> 
> /*要实现的比较运算是: a<b?-1;a>b?1:0*/
> 
> typedef int (CV\_CDECL\* CvCmpFunc)(const void\* a, const void*b,void* userdata);
> 
> 格式
> 
> void cvSeqSort(CvSeq\* seq,CvCmpFunc,void\* userdata = NULL);
> 
> 参数
> 
> seq 待排序的序列
> 
> func 比较函数,按照元素间的大小关系返回负数,零,或者正数
> 
> userdata 传递给比较函数的用户参数,在某些情况下,可避免全局变量的使用
> 
> 说明
> 
> 函数cvSeqSort使用特定的标准对序列进行排序.下面是一个函数实例

static int cmp_func(const void* _a,const void* _b,void* userdata)
    {
        CvPoint* a = (CvPoint*)_a;
        CvPoint* b = (CvPoint*)_b;
        int y_diff = a->y - b->y;
        int x_diff = a->x - b->x;
        return  y_diff ? y_diff : x_diff;
    }
        CvMemStorage* storage = cvCreateMemStorage(0);
        CvSeq* seq = cvCreateSeq(CV_32SC2,sizeof(CvSeq),sizeof(CvPoint),storage);
        int i;
        for (int i=0;i<10;i++)
        {
            CvPoint pt;
            pt.x = rand() % 1000;
            pt.y = rand() % 1000;
            cvSeqPush(seq,&pt);
        }
        cvSeqSort(seq,cmp_func,0);
        //输出结果
        for (i=0;i < seq->total;i++)
        {
            CvPoint* pt = (CvPoint*) cvGetSeqElem(seq,i);
            printf("(%d,%d)",pt->x,pt->y);
        }
        cvReleaseMemStorage(&storage);

(22)SeqSearch

> 功能
> 
> 函数cvSeqSearch查询序列中的元素
> 
> 在使用比较函数之前应先进行如下声明
> 
> /*要实现的比较运算是: a < b ? -1 :a > b ?1 : 0*/
> 
> typedef int (Cv\_CDECL \* CvCmpFunc)(Const void\* a,const void \* b, void \* userdata);
> 
> 格式
> 
> char\* cvSeqSearch(CvSeq\* seq,const void\* elem, CvCmpFunc func , int is\_sorted , int \* elem\_idx, void \* userdata = NULL);
> 
> 参数
> 
> seq 序列
> 
> elem 待查询的元素
> 
> func 比较函数,按照元素间的大小关系放回负数,零或正数(见函数cvSeqSort中的解释)
> 
> is\_sorted 标志序列是否已经排序
> 
> elem\_idx 输出参数,已查找到的元素索引值
> 
> Userdata 传递到比较函数的用户参数,在某些情况下,有助于避免使用全局变量.
> 
> 说明
> 
> 函数cvSeqSearch查找序列中的元素.如果序列已被排序,则使用二分查找(事件复杂度为O\[log(N)\]);否则使用简单线性查找.若查找元素不存在,则函数返回NULL指针,而将索引值设置为序列中的元素数(当使用线性查找时)或者是能够满足表达式seq(i) > elem的最小i值

(23)StartAppendToSeq

> 功能
> 
> 函数cvStartAppendToSeq将数据写如序列中,并初始化该过程
> 
> 格式
> 
> void cvStartAppendToSeq(CvSeq\* seq,CvSeqWriter\* writer);
> 
> 参数
> 
> seq 指向序列的指针
> 
> writer 写入部分的状态,由此函数初始化
> 
> 说明
> 
> 函数cvStartAppendToSeq对数据写入序列的过程初始化.通过宏CV\_WRITE\_SEQ\_ELEM(wtitten\_elem,writer)可以将要写入的元素添加到序列的尾部.
> 
> 注意 在写入期间,对序列的其他操作可能会产生错误的结果,甚至破坏该序列(具体说明参见函数cvFlishSeqWriter的相关描述,有助于避免这些错误).

(24)StartWriterSeq

> 功能
> 
> 函数cvStartWriteSeq创建新序列,并初始化写入状态
> 
> 格式
> 
> void cvStartWriteSeq(int seq\_flags, int header\_size, int elem\_size,CvMemStorage\* storage, CvSeqWriter\* writer);
> 
> 参数
> 
> seq\_flags 标志被创建的序列.如果序列还未传递给任何可处理特定序列类型的函数,则序列值等于0;否则,必须从之前定义的序列类型中选择一个合适的类型.
> 
> header\_size 头部的大小.此参数值不小于sizeof(CvSeq).如果定义了某一类型或其扩展,则次参数必须与所定义类型的头大小相同
> 
> elem\_size 元素的大小(以字节计),必须与序列类型一致.例如,如果创建了包含指针的序列(元素类型为CV\_SEQ\_ELTYPE\_POINT),那么elem\_size必须等于sizeof(CvPoint).
> 
> storage 序列(在内存的位置)
> 
> writer 写入部分的状态,由此函数初始化
> 
> 说明
> 
> 函数cvStartWriteSeq是函数cvCreateSeq与函数cvStartAppendToSeq的组合.指向被创建的序列指针存放在writer->seq中,该指针通过函数cvEndWriterSeq放回(应当在最后调用).

(25)EndWriteSeq

> 功能
> 
> 函数cvEndWriteSeq
> 
> 格式
> 
> CvSeq\* cvEndWriteSeq(CvSeqWriter\* writer);
> 
> 参数
> 
> writer 写入部分的状态
> 
> 说明
> 
> 函数cvEndWriteSeq完成写入操作并返回指向被写入元素的序列的地址,同事,函数将截取最后那个不完整的序列块.块的剩余部分返回到内存之后,序列即可以被安全地读和写.

(26)FlushSeqWriter

> 功能
> 
> 函数cvFlushSeqWriter根据写入状态刷新序列头部
> 
> 格式
> 
> void cvFlushSeqWriter(CvSeqWriter\* writer);
> 
> 参数
> 
> writer 写入部分的状态
> 
> 说明
> 
> 函数cvFlishSeqWriter用来在写入过程中使用户在需要时读取序列中的元素,例如核查指定的条件.函数更新序列的头部,从而使读取序列中的数据成为可能.不过,写如操作并没有被关闭,因此随时都可以将数据写入序列.在某些需要经常刷新的算法中,应考虑使用cvSeqOush来代替此函数.

(27)StartReadSeq

> 功能
> 
> 函数cvStartReadSeq初始化序列中的读取过程
> 
> 格式
> 
> void cvStartReadSeq(const CvSeq\* seq ,CvSeqRead\* redaer,int reverse=0);
> 
> 参数
> 
> seq 序列
> 
> reader 读取部分的状态,有此函数初始化
> 
> reverse 决定遍历序列的方向.如果为0,则读取顺序为从序列头部的元素开始;否则,从序列尾部开始.
> 
> 说明
> 
> 函数cvStartReadSeq初始化读取部分的状态.顺序读取可通过调用宏CV\_READ\_SEQ\_ELEM(read\_elem,reader)实现.逆序读取可通过调用宏CV\_REV\_READ\_SEQ\_ELEM(read\_elem,reader)实现.这两个宏都将序列元素读入read\_elem中,并将指针移到下一个元素.下列代码显示如果使用reader和writer

CvMemStorage* storage = cvCreateMemStorage(0);
        CvSeq* seq = cvCreateSeq(CV_32SC1,sizeof(CvSeq),sizeof(int),storage);
        CvSeqWriter writer;
        CvSeqReader reader;
        int i;
        cvStartAppendToSeq(seq,&writer);
        for (i=0;i<10;i++)
        {
            int val = rand() % 100;
            CV_WRITE_SEQ_ELEM(val,writer);
            printf("%d is written\n",val);
        }
        cvEndWriteSeq(&writer);
     
        cvStartReadSeq(seq,&reader,0);
        for (i=0;i<seq->total;i++)
        {
            int val;
    #if 1
            CV_READ_SEQ_ELEM(val,reader);
            printf("%d is read\n",val);
    #else 
            printf("%d is read\n",*(int*)reader.ptr);
            CV_NEXT_SEQ_ELEM(seq->elem_size,reader);
    #endif
        }
        cvReleaseMemStorage(&storage);

(28)GetSeqReaderPos

> 功能
> 
> 函数cvGetSeqReaderPos返回当前读取器的位置
> 
> 格式
> 
> int cvGetSeqReaderPos(CvSeqReader\* reader);
> 
> 参数
> 
> reader 读取器的状态
> 
> 说明
> 
> 函数cvGetSeqReaderPos放回当前reader的位置在(0到reader->seq->total-1之间)

(29)SetSeqReaderPos

> 功能
> 
> 函数cvSetSeqReaderPos移动读取器到指定的位置
> 
> 格式
> 
> void cvSetSeqReaderPos(CvSeqReader\* reader,int index, int is\_relative = 0);
> 
> 参数
> 
> reader 读取器的状态
> 
> index 索引的位置.如果使用绝对位置,则实际位置为index % reader->seq->total.
> 
> is\_relative 如果不为0,则索引(index)值为相对位置
> 
> 说明
> 
> 函数cvSetSeqReaderPos将读取器的位置移动到绝对位置,或相对于当前位置的相对位置上.

### 1.detectMultiScale函数介绍 ###

打开opencv源码，具体位置在opencv-3.2.0/modules/objdetect/src/cascadedetect.hpp 。 查看源代码可发现detectMultiscale函数有三种：
         void detectMultiScale( InputArray image,
                          CV_OUT std::vector<Rect>& objects,
                          double scaleFactor = 1.1,
                          int minNeighbors = 3, int flags = 0,
                          Size minSize = Size(),
                          Size maxSize = Size() );
    
    void detectMultiScale( InputArray image,
                          CV_OUT std::vector<Rect>& objects,
                          CV_OUT std::vector<int>& numDetections,
                          double scaleFactor=1.1,
                          int minNeighbors=3, int flags=0,
                          Size minSize=Size(),
                          Size maxSize=Size() );
    
    void detectMultiScale( InputArray image,
                          CV_OUT std::vector<Rect>& objects,
                          CV_OUT std::vector<int>& rejectLevels,
                          CV_OUT std::vector<double>& levelWeights,
                          double scaleFactor = 1.1,
                          int minNeighbors = 3, int flags = 0,
                          Size minSize = Size(),
                          Size maxSize = Size(),
                          bool outputRejectLevels = false );

> 参数1：image–待检测图片，一般为灰度图像加快检测速度；
> 
> 参数2：objects–被检测物体的矩形框向量组；为输出量，如人脸检测矩阵Mat
> 
> 参数3：scaleFactor–表示在前后两次相继的扫描中，搜索窗口的比例系数。默认为1.1即每次搜索窗口依次扩大10%;一般设置为1.1
> 
> 参数4：minNeighbors–表示构成检测目标的相邻矩形的最小个数(默认为3个)。 如果组成检测目标的小矩形的个数和小于 min\_neighbors - 1 都会被排除。 如果min\_neighbors 为 0, 则函数不做任何操作就返回所有的被检候选矩形框， 这种设定值一般用在用户自定义对检测结果的组合程序上；
> 
> 参数5：flags–要么使用默认值，要么使用CV\_HAAR\_DO\_CANNY\_PRUNING，如果设置为CV\_HAAR\_DO\_CANNY\_PRUNING，那么函数将会使用Canny边缘检测来排除边缘过多或过少的区域，因此这些区域通常不会是人脸所在区域；
> 
> 参数6、7：minSize和maxSize用来限制得到的目标区域的范围。也就是我本次训练得到实际项目尺寸大小 函数介绍： detectMultiscale函数为多尺度多目标检测： 多尺度：通常搜索目标的模板尺寸大小是固定的，但是不同图片大小不同，所以目标对象的大小也是不定的，所以多尺度即不断缩放图片大小（缩放到与模板匹配），通过模板滑动窗函数搜索匹配；同一副图片可能在不同尺度下都得到匹配值，所以多尺度检测函数detectMultiscale是多尺度合并的结果。 多目标：通过检测符合模板匹配对象，可得到多个目标，均输出到objects向量里面。

[http_wiki.opencv.org.cn_index.php]: http://wiki.opencv.org.cn/index.php/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E4%B8%AD%E6%96%87%E5%8F%82%E8%80%83%E6%89%8B%E5%86%8C