算法思想：我们把要跟踪的目标保存好，然后在每一帧来临的时候，我们在整个图像中寻找与这个目标最相似的，我们就相信这个就是目标了。
相似性的计算——模板匹配中差值的平方和（SSD）与互相关准则的关系
http://blog.csdn.net/zouxy09/article/details/8549743
实现函数：
     void matchTemplate( const Mat& image, const Mat& templ, Mat&result, int method );
      该函数的功能为，在输入源图像Sourceimage（I）中滑动框，寻找各个位置与模板图像Template image（T）的相似度，并将结果保存在结果矩阵result matrix（R）中。该矩阵的每一个点的亮度表示与模板T的匹配程度。然后可以通过函数minMaxLoc定位矩阵R中的最大值（该函数也可以确定最小值）。
minMaxLoc函数原型: 

void minMaxLoc( const Mat& src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, const Mat& mask=Mat() ); 
void minMaxLoc(const MatND& src, double* minVal, double* maxVal, int* minIdx=0, int* maxIdx=0, const MatND& mask=MatND() ); 
void minMaxLoc(const SparseMat& src, double* minVal, double* maxVal, int* minIdx=0, int* maxIdx=0);

说明：
1 minMaxLoc寻找矩阵(一维数组当作向量,用Mat定义) 中最小值和最大值的位置. 
2 参数若不需要,则置为NULL或者0,即可. 
3 minMaxLoc针对Mat和MatND的重载中 ,第5个参数是可选的(optional),不使用不传递即可.

然后为了适应目标的变化，我们就需要随时更新我们要跟踪的目标。换句话来说，在第t帧寻找目标的时候，是与t-1帧中我们找到的目标来进行比较的。这样目标的外观变化就会及时的更新。这个就叫做在线跟踪方法。
缺点：这个策略会导致跟踪漂移的问题，这就是近几年很多跟踪算法关注的重要问题之一了。实际情况下是复杂的，比如多个人在走，互相交叉，画面上人比较小，特征不明显等问题都会出现。例如两个身高体型差不多，衣服颜色也差不多的人互相交叉走过。还会有人走着走着忽然被障碍挡住了，然后重新出现，等等去情况，导致这种程序放到真实环境视频中，根本没法正常使用。

正则匹配字符解释：

^ 表示开头
	
$ 表示结尾
	
. 表示任意字符
	
* 表示任意多个
1、元字符匹配

(.)   表示匹配除换行符以外的任意字符。

(\w) 表示匹配字母、下划线、数字或汉字(\\W)。

(\d) 表示匹配数字

(\s) 表示匹配任意的空白符

([ ])  表示匹配方括号中任一字符

([^匹配内容]) 表示匹配方括号中任一字符

2、位置匹配

(^) 表示匹配字符串的开始，空值:^$

($) 表示匹配字符串的结束

(\b) 表示匹配单词的开始或结束。

(\B) 表示匹配非单词的开始或结束

3、频率匹配

(*) 表示匹配重复0次或多次

(+) 表示匹配重复一次或更多次

(?) 表示匹配重复0次或1次

({n}) 表示匹配重复n次

({n,}) 表示重复n次或更多次

({n,m}) 表示重复n到m次

正则匹配函数：regexp_extract函数

用法：

regexp_extract(string subject, string pattern, int index)

 

1）regexp_extract函数

语法:    regexp_extract(string subject,  string pattern,  int index)

返回值: string

说明：  将字符串subject按照pattern正则表达式的规则拆分，返回index指定的字符。

第一参数：   要处理的字段

第二参数:    需要匹配的正则表达式

第三个参数:

0是显示与之匹配的整个字符串
	
1 是显示第一个括号里面的
	
2 是显示第二个括号里面的字段...
 

注意，在有些情况下要使用转义字符（双斜杠了‘\\’）。

2） regexp_substr

regexp_substr(string, regex,postion,match_parameter)

  string : 被解析的字符串或字段名

  regex: 正则表达式

  postion：其实位置

  match_parameter：出现的次数

 

For example：

                  select regexp_substr('别克-君威2010款 2.4L A.MT 旗舰版2.3T','[[:alnum:]][[:punct:]][[:alnum:]][LT]',1,1)  from dual

                 分析： 上面正则的意思是 [[:alnum:]][[:punct:]][[:alnum:]][LT]  ===> 任何字母(不区分大小写)和数字+ 任何标点符号+任何字母和数字 +（L或者T）的组合

                  后面   1,1 的意思是从匹配的字符串起，符合正则且第一次出现的字符串

                  结果：  2.4L

                 

                 换个方式提取  A.MT SQL语句如下

                select regexp_substr('别克-君威2010款 2.4L A.MT 旗舰版2.3T','[[:alnum:]][[:punct:]][[:alnum:]][LT]',1,2)  from dual

                如果提取2.3T ，把最后那个数字改成3即可，就不写sql了。累！

                

                 select

                 REGEXP_SUBSTR('9.00w','([0-9]*)[[:punct:]]([0-9]*)',1,1) 

                 from dual

                大家可以验证一下这个语句！

      3）regexp

 regexp的用法比较简单，就是个判断语句跟like、=、！=、not in 、in 的感觉一样

 

1、关于正则表达式的符号及意义

正则表达式由标准的元字符（metacharacters）所构成：

 

/
			

			
做为转意，即通常在"/"后面的字符不按原来意义解释，如/b/匹配字符"b"，当b前面加了反斜杆后//b/，转意为匹配一个单词的边界。

			-或- 

			对正则表达式功能字符的还原，如"*"匹配它前面元字符0次或多次，/a*/将匹配a,aa,aaa，加了"/"后，/a/*/将只匹配"a*"。
			
		
^
			
匹配一个输入或一行的开头，/^a/匹配"an A"，而不匹配"An a"
		
$
			
匹配一个输入或一行的结尾，/a$/匹配"An a"，而不匹配"an A"
		
*
			
匹配前面元字符0次或多次，/ba*/将匹配b,ba,baa,baaa
		
+
			
匹配前面元字符1次或多次，/ba*/将匹配ba,baa,baaa
		
?
			
匹配前面元字符0次或1次，/ba*/将匹配b,ba
		
(x)
			
匹配x保存x在名为$1...$9的变量中
		
x|y
			
匹配x或y
		
{n}
			
精确匹配n次
		
{n,}
			
匹配n次以上
		
{n,m}
			
匹配n-m次
		
[xyz]
			
字符集(character set)，匹配这个集合中的任一一个字符(或元字符)
		
[^xyz]
			
不匹配这个集合中的任何一个字符
		
[/b]
			
匹配一个退格符
		
/b
			
匹配一个单词的边界
		
/B
			
匹配一个单词的非边界
		
/cX
			
这儿，X是一个控制符，//cM/匹配Ctrl-M
		
/d
			
匹配一个字数字符，//d/ = /[0-9]/
		
/D
			
匹配一个非字数字符，//D/ = /[^0-9]/
		
/n
			
匹配一个换行符
		
/r
			
匹配一个回车符
		
/s
			
匹配一个空白字符，包括/n,/r,/f,/t,/v等
		
/S
			
匹配一个非空白字符，等于/[^/n/f/r/t/v]/
		
/t
			
匹配一个制表符
		
/v
			
匹配一个重直制表符
		
/w
			
匹配一个可以组成单词的字符(alphanumeric，这是我的意译，含数字)，包括下划线，如[/w]匹配"$5.98"中的5，等于[a-zA-Z0-9]
		
/W
			
匹配一个不可以组成单词的字符，如[/W]匹配"$5.98"中的$，等于[^a-zA-Z0-9]。
		
'( )' 标记一个子表达式的开始和结束位置。

'[]' 标记一个中括号表达式。

/num 匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。

字符簇： 

[[:alpha:]] 任何字母。

[[:digit:]] 任何数字。

[[:alnum:]] 任何字母和数字。

[[:space:]] 任何白字符。

[[:upper:]] 任何大写字母。

[[:lower:]] 任何小写字母。

[[:punct:]] 任何标点符号。

[[:xdigit:]] 任何16进制的数字，相当于[0-9a-fA-F]

 

[[:<:]],[[:>:]] 标记表示word边界。它们分别与word的开始和结束匹配。word是一系列字字符，其前面和后面均没有字字符。字字符是alnum类中的字母数字字符或下划线(_)

 

各种操作符的运算优先级：

/ 转义符

(), (?:), (?=), [] 圆括号和方括号

*, +, ?, {n}, {n,}, {n,m} 限定符

^, $, anymetacharacter 位置和顺序

 

2、regexp_extract函数

regexp_extract(str, regexp[, idx]) - extracts a group that matches regexp

字符串正则表达式解析函数。

 

参数解释:

其中：

str是被解析的字符串或字段名

regexp 是正则表达式

idx是返回结果 取表达式的哪一部分  默认值为1。

0表示把整个正则表达式对应的结果全部返回

1表示返回正则表达式中第一个() 对应的结果 以此类推 

        当向linux系统总线添加设备或驱动时，总是会调用各总线对应的match匹配函数来判断驱动和设备是否匹配，这些match函数之间都存在一定的差异，本文先对常用的match匹配函数进行讲解，以后会陆续添加新的内容。 
一. 驱动和设备匹配过程常用数据结构
1. of_device_id

struct of_device_id

{
charname[32];
char type[32];
char compatible[128];
#ifdef __KERNEL__
void*data;
#else
kernel_ulong_t data;
#endif
};
2. platform_device_id
struct platform_device_id {

char name[PLATFORM_NAME_SIZE];
kernel_ulong_t driver_data   __attribute__((aligned(sizeof(kernel_ulong_t))));

};

二. 平台设备、驱动匹配platform_match
          向系统添加平台驱动或添加设备时会调用平台总线platform_bus_type中的platform_match函数来匹配平台驱动和平台设备。
static int platform_match(struct device *dev, struct device_driver *drv)

{


struct platform_device *pdev = to_platform_device(dev);
struct platform_driver *pdrv = to_platform_driver(drv);
/*通过驱动里定义了of_device_id项，则通过这一项来比对；*
if (of_driver_match_device(dev, drv))



return 1;



/*如果在平台驱动中定义了id_table项，则通过对比id_table来判断*/
if (pdrv->id_table)



return platform_match_id(pdrv->id_table, pdev) != NULL;



/*通过对比平台设备名字和平台驱动名字来判断*/
return (strcmp(pdev->name, drv->name) == 0);

}

           由platform_match可以看出，驱动和设备是否匹配可以通过三种方式来进行判断，首先是通过of_device_id结构：
static inline int of_driver_match_device(struct device *dev, const struct device_driver *drv)

{


return of_match_device(drv->of_match_table, dev) != NULL;

}

struct of_device_id *of_match_device(const struct of_device_id *matches, const struct device *dev)

{


if ((!matches) || (!dev->of_node))



return NULL;



return of_match_node(matches, dev->of_node);

}

const struct of_device_id *of_match_node(const struct of_device_id *matches, const struct device_node *node)
{


if (!matches)



return NULL;



while (matches->name[0] || matches->type[0] || matches->compatible[0]) {


int match = 1;
if (matches->name[0])



match &= node->name && !strcmp(matches->name, node->name);



if (matches->type[0])



match &= node->type && !strcmp(matches->type, node->type);



if (matches->compatible[0])



match &= of_device_is_compatible(node, matches->compatible);



if (match)



return matches;




matches++;


}

return NULL;

}

         如果driver中定义了of_device_id，则通过driver中的of_device_id和device中的device_node内容进行匹配判断，匹配工作由of_match_node来完成，该函数会遍历of_device_id列表，查找是否有成员与device_node相匹配，具体由matches的name,type和compatioble来进行对比，如果找到则返回相应的表项，否则返回null.如果没有定义of_device_id,device_node或不能找到对应的匹配项，则通过第二种方式platform_device_id来进行对比匹配,通过platform_match_id来完成：
static const struct platform_device_id *platform_match_id( const struct platform_device_id *id, struct platform_device *pdev)

{


while (id->name[0]) {



if (strcmp(pdev->name, id->name) == 0) {




pdev->id_entry = id;







return id;




}


id++;



}
return NULL;


}
        platform_match_id函数遍历platfrom_device_id列表，通过比对平台设备与id的name来确定是否有匹配项，如果找到匹配的，则返回对应的id项，否则返回null。如果没有定义platform_device_id或没有找到匹配项，则通过第三种方式进行匹配，第三种方式通过比对平台设备和平台驱动的名字，如果相等，则匹配成功，否则失败。
三. i2c设备、驱动匹配i2c_device_match
         当向i2c总线添加驱动或设备时会调用i2c_device_match来进行匹配判断，i2c_device_match函数定义如下所示：
static int i2c_device_match(struct device *dev, struct device_driver *drv)
{


struct i2c_client*client = i2c_verify_client(dev);
struct i2c_driver * driver;
if (!client)



return 0;



/* 通过of_device_id匹配 */
if (of_driver_match_device(dev, drv))



return 1;



driver = to_i2c_driver(drv);
/*如果I2C 驱动中定义了id_table，则通过id_table进行匹配；*/
if (driver->id_table)



return i2c_match_id(driver->id_table, client) != NULL;



return 0;

}

如i2c_device_match所示，i2c通过两种方式进行匹配设备和驱动，一种是of_device_id，另一种是i2c_device_id，i2c_device_id数据结构和platform_device_id一样。I2C里的两种匹配方式和之前的platform判断方式都是一样，这里就不展开。
四. usb设备、驱动匹配usb_device_match

当向usb总线上注册驱动或添加设备时，就会调用usb_match_device进行驱动和设备配对，函数如下：

static int usb_device_match(struct device *dev, struct device_driver *drv)
{

if (is_usb_device(dev)) {



if (!is_usb_device_driver(drv))





return 0;





return 1;



} else if (is_usb_interface(dev)) {



struct usb_interface *intf;


struct usb_driver *usb_drv;


const struct usb_device_id *id;


if (is_usb_device_driver(drv))





return 0;





intf = to_usb_interface(dev);


usb_drv = to_usb_driver(drv);


id = usb_match_id(intf, usb_drv->id_table);


if (id)





return 1;





id = usb_match_dynamic_id(intf, usb_drv);


if (id)





return 1;




}
return 0;

}
        从函数可以看出，match分成两部分，一部分用于匹配usb设备，另一部分用于匹配usb 接口，对于usb设备，在初始化时会设置成usb_device_type，而usb接口，则会设成usb_if_device_type。而函数中的is_usb_device和is_usb_interface就是通过这两个属性来判别的，如果为判定为设备，则进入到设备分支，否则进入到接口分支继续判断。
        usb设备驱动通过usb_register_device_driver接口来注册到系统，而usb接口驱动则通过usb_register来注册到系统，驱动工程师的工作基本上集中在接口驱动上，所以通常是通过usb_register来注册usb驱动的。 
        不管是设备驱动usb_device_driver,还是接口驱动usb_driver数据结构中都包含了struct usbdrv_wrap项，其定义如下：

struct usbdrv_wrap {

struct device_driver driver;
int for_devices;

}

         数据结构中的for_devices用来表示该驱动是设备驱动还是接口驱动，如果为设备驱动，则在用usb_register_device_driver注册时，会将该变量for_devices设置成1，而接口驱动则设为0.

        usb_device_match中的is_usb_device_driver函数就是通过获取上而结构中的for_devices来进行判断是设备还是接口驱动的，函数定义如下：
static inline int is_usb_device_driver(struct device_driver *drv)
{


return container_of(drv, struct usbdrv_wrap, driver)->for_devices;

}
        当进入is_usb_device分支后，再通过is_usb_device_driver来判断是否为设备驱动，如果是则返回1，表示匹配成功，它接受所有usb设备。
        当进入到接口分支后，也会先用is_usb_device_driver来进行判断，如果不是设备驱动则继续判断，否则退出；然后再通过usb_match_id函数来判断设备和驱动中的usb_device_id是否匹配，usb_match_id定义如下：
const struct usb_device_id *usb_match_id(struct usb_interface *interface,  const struct usb_device_id *id)

{


if (id == NULL)



return NULL;



for (; id->idVendor || id->idProduct || id->bDeviceClass ||  id->bInterfaceClass || id->driver_info; id++) {



if (usb_match_one_id(interface, id))





return id;




}
return NULL;

}
         遍历接口驱动中的usb_device_id列表项，只要usb_device_id结构中的idVendor,idProduct,DeviceClass,binterfaceClass,driver_info项有效就调用usb_match_one_id进行判断，如找到匹配项则函数返回1，否则返回0 。
int usb_match_one_id(struct usb_interface *interface,const struct usb_device_id *id)

{


struct usb_host_interface *intf;
struct usb_device *dev;
if (id == NULL)



return 0;



intf = interface->cur_altsetting;
dev = interface_to_usbdev(interface);
if (!usb_match_device(dev, id))



return 0;


if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC && 


 !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&


(id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS | USB_DEVICE_ID_MATCH_INT_PROTOCOL)))



return 0;


if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&


 (id->bInterfaceClass != intf->desc.bInterfaceClass))




return 0;



if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) && 



(id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))




return 0;



if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) && 



 (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))



return 0;


return 1;

}


usb_match_one_id和函数中的usb_match_device都是围绕着usb_device_id进行匹配的，该结构定义如下：

struct usb_device_id {


/* which fields to match against? */
__u16 
match_flags;
/* Used for product specific matches; range is inclusive */
__u16 
idVendor;
__u16 
idProduct;
__u16 
bcdDevice_lo;
__u16 
bcdDevice_hi;
/* Used for device class matches */
__u8 
bDeviceClass;
__u8 
bDeviceSubClass;
__u8 
bDeviceProtocol;
/* Used for interface class matches */
__u8 
bInterfaceClass;
__u8 
bInterfaceSubClass;
__u8 
bInterfaceProtocol;
/* not matched against */
kernel_ulong_tdriver_info;

};
          match_flags用来规定驱动匹配时的具体项，如match_flags包含USB_DEVICE_ID_MATCH_VENDOR，则是通过驱动中的usb_device_id和设备dev中的idVendor来判断。

通配符是 shell 命令中的重要功能，

? 表示匹配任意 1 个字符，

*表示匹配 0 个或多个字符。

请使用你熟悉的编程语言实现一个字符串匹配函数，

支持 ? 和 * 通配符。如 “a?cd*d” 匹配 “abcdaccd”