博客园_无涯（C、.net、图像处理、算法）

解决Windows7无法安装SP1补丁包及无法显示Windows功能列表的方法

2011-07-24T00:36:00Z

作者：王先荣

好几个月以前我的电脑上就不能显示Windows7的功能列表，这样就导致了我无法添加或者卸载Windows组件，例如IIS等等。而在更新SP1补丁时，也总是更新失败，提示FILE_NOT_FOUND错误。

我的解决办法取自多个问答网站，步骤如下：

1.首先，在服务里面确保BITS已启动，并设置属性为“自动——延迟加载”；

2.手动下载并安装补丁“Windows6.1-KB947821-v12-x86.msu”；

3.手动下载并安装SP1补丁“windows6.1-KB976932-X86.exe”。

如果是64位版本的Windows7，也许需要将文件名中的x86修改成x64。

通过上述操作之后，SP1更新成功，而“打开或关闭windows功能“也正常了～～

本文链接

使用Lingobit Localizer汉化.net程序（Translate .net program using Lingobit Localizer）

2011-06-06T14:51:00Z

作者：王先荣

前言
    最近开始做给小朋友上机器人编程课的兼职，感概颇多：（1）小朋友的动手能力都很强；（2）“调皮”的小孩很多；（3）直面困难的小朋友不多。
    由于采用的教具是韩国人做的HunaRobo，满屏的英文对8～12岁的小孩来说，挑战蛮大的。因此萌生了将HunaRobo汉化的想法。
    本文主要讲述如何汉化HunaRobo这款.net2.0软件，使用的辅助工具是Lingobit Localizer 7.1。当然您也可以用这款工具及本文所述方法将其他软件翻译成您需要的语言。

辅助工具的选择
    在开始汉化之前，需要选择一款辅助工具，以减少工作量。在Google中搜索了“.net 程序汉化”这组关键词之后，查看了其中的文章《.NET程序汉化实例》和《.NET 程序初级汉化流程一例》。这两篇文章写得都很好，对从未接触过汉化的我启发很大。不过文中提到的方法和工具都不太好用，很麻烦。继续搜索并试用了不少本地化辅助软件，最终选定了Lingobit Localizer 7.1作为我此次汉化的工具。
    对于初次接触汉化的我来说，Lingobit Localizer提供了极大的方便，几乎不费力就完成了汉化工作。

下载并安装Lingobit Localizer
    您可以到Lingobit官网下载到该软件，地址是：http://www.lingobit.com/localizer.exe
    安装的过程很简单，一路点“NEXT”和“FINISH”就行了。
    共享版可以免费使用90天，不过在汉化的结果中会随机在您的部分汉化字符串之前增加该公司的名称“_Lingobit_”。

汉化过程
    下面讲述使用Lingobit Localizer汉化HunaRobo的过程：

英文版的HunaRobo

汉化之后的HunaRobo

1. 将Lingobit Localizer的界面设置为中文
    依次点击菜单“View->User Interface Language->中文（简体）（中华人民共和国）”，然后退出并重新进入程序即可。

2. 新建待翻译项目
    （1）点击“新建项目”，将项目名称改为“HunaRobo”，然后点击“下一步”按钮。

    （2）选择应用程序的原始语言为“English（英语）”，然后添加目标语言“Chinese Simplified（简体中文）”，点击“下一步”按钮。

    （3）点击“添加文件”按钮，选择并添加我们的待汉化可执行程序文件“HunaRobo.exe”，点击“下一步”按钮。

    （4）点击“完成”按钮。

    这样就创建好了我们的待翻译项目。
3. 翻译字符串
    项目在刚创建完成之后，窗体的左边是待翻译资源的分类列表，右边是选中类别的待翻译条目，一共有3种状态：未翻译、翻译中、自动。其中的“翻译中”我觉得改为“已翻译”更加恰当。
    对于字符串，我们只需要在“Chinese (Simplified)”栏将英文对应的中文填写进去即可。

4. 翻译图片中的英文
    一般的程序中都会有一些图片，例如工具栏、图示等处所。翻译图片的过程相对翻译字符串稍微复杂点，不过有Lingobit Localizer的帮助其实也很简单。
    （1）保存待翻译的图片：右键点击待翻译的条目，依次点击弹出菜单中的“二进制数据->保存原文”，在保存对话框中输入图像名称（注意扩展名），然后保存它。

    （2）在“画图”或者别的图像编辑软件中将英文替换成中文，并保存它。

    （3）再次右键点击待翻译的条目，依次点击弹出菜单中的“二进制数据->装入已翻译内容”，选择并打开在（2）中编辑过的图片。

5. 创建本地化文件
    点击工具栏中的“创建”按钮即可。

6. 使用汉化文件
    将翻译项目所在目录中的“zh-CN”目录复制到程序所在目录即可。
7. 禁用汉化文件
   删除程序所在目录中的“zh-CN”目录。

Lingobit Localizer的缺点
    第一次汉化软件的我在Lingobit Localizer的帮助下成功的汉化了HunaRobo，可见Lingobit Localizer非常好用。但是在短短的使用过程中我也发现了它的一些不足：
    （1）共享版会在汉化结果中随机添加讨厌的字符串“_Lingobit_”；
    （2）Lingobit Localizer非常贵 -_- ；
    （3）Lingobit Localizer不能直接用来汉化固化在程序中的字符串，而必须借助其他工具来翻译il文件中的字符串。

汉化包下载
    如果要下载HunaRobo的汉化包，请点击这里。

感谢您看完本文，希望对您有所帮助。

本文链接

javascript获取到textarea文本框中的回车换行符

2011-04-27T14:46:00Z

作者：王先荣

结论

javascript获取到textarea文本框中的字符串中，如果包含有回车换行符，在字符串中表现为“\n”，而不是我们通常所见的“\r\n”。

发现问题

今天在做小网站的时候，需要将用户输入的英文分号、中英文逗号及回车都替换成中文分号，在编javascript函数的过程中，总是无法正确的替换回车。

例如：用户在textarea中输入：

测试字符串1

测试字符串2

我们将textarea中的输入字符串保存到变量content中，下面的替换语句不会将回车替换成中文分号。

content = content.replace("\r\n","；");

解决问题

通过google大法（在google中搜索关键字“javascript substr \r\n”），找到了Ben先生的文章《Ask Ben: Javascript Replace And Multiple Lines / Line Breaks》，里面有非常详细的解释。

拓展

如果我们要获取用户在textarea中输入的回车位置，需要使用类似下面的代码：

var pos = content.indexOf("\n");

如果我们需要将回车替换为别的字符，例如分号，需要使用类似下面的代码：

content = content.replace("\n","；");

完整代码

本文的完整代码如下所示：

//用中文分号替换英文分号、中英文逗号或者回车
        function ReplaceSeperator(mobiles) {
            var i;
            var result = "";
            var c;
            for (i = 0; i < mobiles.length; i++) {
                c = mobiles.substr(i, 1);
                if (c == ";" || c == "," || c == "，" || c == "\n")
                    result = result + "；";
                else if (c != "\r")
                    result = result + c;
            }
            return result;
        }

本文链接

随机抽样一致性算法（RANSAC）

2011-03-09T14:04:00Z

作者：王先荣
    本文翻译自维基百科，英文原文地址是：http://en.wikipedia.org/wiki/ransac，如果您英语不错，建议您直接查看原文。
    RANSAC是“RANdom SAmple Consensus（随机抽样一致）”的缩写。它可以从一组包含“局外点”的观测数据集中，通过迭代方式估计数学模型的参数。它是一种不确定的算法——它有一定的概率得出一个合理的结果；为了提高概率必须提高迭代次数。该算法最早由Fischler和Bolles于1981年提出。
    RANSAC的基本假设是：
（1）数据由“局内点”组成，例如：数据的分布可以用一些模型参数来解释；
（2）“局外点”是不能适应该模型的数据；
（3）除此之外的数据属于噪声。
    局外点产生的原因有：噪声的极值；错误的测量方法；对数据的错误假设。
    RANSAC也做了以下假设：给定一组（通常很小的）局内点，存在一个可以估计模型参数的过程；而该模型能够解释或者适用于局内点。

本文内容
1 示例
2 概述
3 算法
4 参数
5 优点与缺点
6 应用
7 参考文献
8 外部链接

一、示例
一个简单的例子是从一组观测数据中找出合适的2维直线。假设观测数据中包含局内点和局外点，其中局内点近似的被直线所通过，而局外点远离于直线。简单的最小二乘法不能找到适应于局内点的直线，原因是最小二乘法尽量去适应包括局外点在内的所有点。相反，RANSAC能得出一个仅仅用局内点计算出模型，并且概率还足够高。但是，RANSAC并不能保证结果一定正确，为了保证算法有足够高的合理概率，我们必须小心的选择算法的参数。

左图：包含很多局外点的数据集右图：RANSAC找到的直线（局外点并不影响结果）

二、概述
    RANSAC算法的输入是一组观测数据，一个可以解释或者适应于观测数据的参数化模型，一些可信的参数。
    RANSAC通过反复选择数据中的一组随机子集来达成目标。被选取的子集被假设为局内点，并用下述方法进行验证：
    1.有一个模型适应于假设的局内点，即所有的未知参数都能从假设的局内点计算得出。
    2.用1中得到的模型去测试所有的其它数据，如果某个点适用于估计的模型，认为它也是局内点。
    3.如果有足够多的点被归类为假设的局内点，那么估计的模型就足够合理。
    4.然后，用所有假设的局内点去重新估计模型，因为它仅仅被初始的假设局内点估计过。
    5.最后，通过估计局内点与模型的错误率来评估模型。
    这个过程被重复执行固定的次数，每次产生的模型要么因为局内点太少而被舍弃，要么因为比现有的模型更好而被选用。

三、算法
    伪码形式的算法如下所示：
输入：
data —— 一组观测数据
model —— 适应于数据的模型
n —— 适用于模型的最少数据个数
k —— 算法的迭代次数
t —— 用于决定数据是否适应于模型的阀值
d —— 判定模型是否适用于数据集的数据数目
输出：
best_model —— 跟数据最匹配的模型参数（如果没有找到好的模型，返回null）
best_consensus_set —— 估计出模型的数据点
best_error —— 跟数据相关的估计出的模型错误

iterations = 0
best_model = null
best_consensus_set = null
best_error = 无穷大
while ( iterations < k )
    maybe_inliers = 从数据集中随机选择n个点
    maybe_model = 适合于maybe_inliers的模型参数
    consensus_set = maybe_inliers

    for ( 每个数据集中不属于maybe_inliers的点）
        if ( 如果点适合于maybe_model，且错误小于t ）
            将点添加到consensus_set
    if （ consensus_set中的元素数目大于d ）
        已经找到了好的模型，现在测试该模型到底有多好
        better_model = 适合于consensus_set中所有点的模型参数
        this_error = better_model究竟如何适合这些点的度量
        if ( this_error < best_error )
            我们发现了比以前好的模型，保存该模型直到更好的模型出现
            best_model = better_model
            best_consensus_set = consensus_set
            best_error = this_error
    增加迭代次数
返回 best_model, best_consensus_set, best_error

    RANSAC算法的可能变化包括以下几种：
    （1）如果发现了一种足够好的模型（该模型有足够小的错误率），则跳出主循环。这样可能会节约计算额外参数的时间。
    （2）直接从maybe_model计算this_error，而不从consensus_set重新估计模型。这样可能会节约比较两种模型错误的时间，但可能会对噪声更敏感。

四、参数
    我们不得不根据特定的问题和数据集通过实验来确定参数t和d。然而参数k（迭代次数）可以从理论结果推断。当我们从估计模型参数时，用p表示一些迭代过程中从数据集内随机选取出的点均为局内点的概率；此时，结果模型很可能有用，因此p也表征了算法产生有用结果的概率。用w表示每次从数据集中选取一个局内点的概率，如下式所示：
    w = 局内点的数目 / 数据集的数目
    通常情况下，我们事先并不知道w的值，但是可以给出一些鲁棒的值。假设估计模型需要选定n个点，wⁿ是所有n个点均为局内点的概率；1 − wⁿ是n个点中至少有一个点为局外点的概率，此时表明我们从数据集中估计出了一个不好的模型。 (1 − wⁿ)^k表示算法永远都不会选择到n个点均为局内点的概率，它和1-p相同。因此，
    1 − p = (1 − wⁿ)^k
    我们对上式的两边取对数，得出

    值得注意的是，这个结果假设n个点都是独立选择的；也就是说，某个点被选定之后，它可能会被后续的迭代过程重复选定到。这种方法通常都不合理，由此推导出的k值被看作是选取不重复点的上限。例如，要从上图中的数据集寻找适合的直线，RANSAC算法通常在每次迭代时选取2个点，计算通过这两点的直线maybe_model，要求这两点必须唯一。
    为了得到更可信的参数，标准偏差或它的乘积可以被加到k上。k的标准偏差定义为：

五、优点与缺点
    RANSAC的优点是它能鲁棒的估计模型参数。例如，它能从包含大量局外点的数据集中估计出高精度的参数。RANSAC的缺点是它计算参数的迭代次数没有上限；如果设置迭代次数的上限，得到的结果可能不是最优的结果，甚至可能得到错误的结果。RANSAC只有一定的概率得到可信的模型，概率与迭代次数成正比。RANSAC的另一个缺点是它要求设置跟问题相关的阀值。
    RANSAC只能从特定的数据集中估计出一个模型，如果存在两个（或多个）模型，RANSAC不能找到别的模型。

六、应用
RANSAC算法经常用于计算机视觉，例如同时求解相关问题与估计立体摄像机的基础矩阵。

七、参考文献

Martin A. Fischler and Robert C. Bolles (June 1981). "Random Sample Consensus: A Paradigm for Model Fitting with Applications to Image Analysis and Automated Cartography". Comm. of the ACM 24: 381–395. doi:10.1145/358669.358692.
David A. Forsyth and Jean Ponce (2003). Computer Vision, a modern approach. Prentice Hall. ISBN 0-13-085198-1.
Richard Hartley and Andrew Zisserman (2003). Multiple View Geometry in Computer Vision (2nd ed.). Cambridge University Press.
P.H.S. Torr and D.W. Murray (1997). "The Development and Comparison of Robust Methods for Estimating the Fundamental Matrix". International Journal of Computer Vision 24: 271–300. doi:10.1023/A:1007927408552.
Ondrej Chum (2005). "Two-View Geometry Estimation by Random Sample and Consensus". PhD Thesis. http://cmp.felk.cvut.cz/~chum/Teze/Chum-PhD.pdf
Sunglok Choi, Taemin Kim, and Wonpil Yu (2009). "Performance Evaluation of RANSAC Family". In Proceedings of the British Machine Vision Conference (BMVC). http://www.bmva.org/bmvc/2009/Papers/Paper355/Paper355.pdf.

八、外部链接

RANSAC Toolbox for MATLAB. A research (and didactic) oriented toolbox to explore the RANSAC algorithm in MATLAB. It is highly configurable and contains the routines to solve a few relevant estimation problems.
Implementation in C++ as a generic template.
RANSAC for Dummies A simple tutorial with many examples that uses the RANSAC Toolbox for MATLAB.
25 Years of RANSAC Workshop

九、后话

本文在翻译的过程中参考了沈乐君的文章《随机抽样一致性算法RANSAC源程序和教程》。Ziv Yaniv已经用C++实现了RANSAC，您可以点击这里下载源程序。

不过，如果时间允许的话，我打算自己动手用C#去实现RANSAC算法，原因有两个：

（1）熟悉算法的最佳途径是自己去实现它；

（2）方便使用.net的同志们利用RANSAC。

感谢您耐心看完我的蹩脚翻译，希望对您有所帮助。

本文链接

返修&售后服务管理网站设计与源码

2011-03-07T03:04:00Z

作者：王先荣
    去年帮朋友做了返修与售后服务管理相关的网站，现在将返修与售后服务的设计及源码开放出来。本文没有技术含量，高手请无视，还请海涵。如果您初学.net，可以下载源码看看我是怎么写的。如果您正好需要做返修及售后服务相关的程序，也可以下载下来参考。好了，废话到此为止，现在开始正题。
一、返修流程
    首先，我根据朋友提供的要求及现有的单据，提炼了返修及售后服务的流程。返修的流程如下图所示，大致分为以下几个步骤：
（1）客户要求保修：客户发现商品有质量问题，跟商家提出保修要求；
（2）商家收货：商家收取商品客户送过来的商品，或者商家上门提取商品；
（3）技术员检测：技术员（工程师）检测商品是否存在客户所述的问题，如果商品的确存在问题，进入第（4）步的返修程序；如果商品没有问题，转入第（6）步，直接将商品退还给客户；
（4）商家发货：商家将有问题的商品发货至上级代理商（或者维修部门）；
（5）商家返回收货：商品维修好（替换）之后，商家从上级代理商（或者维修部门）取回商品；
（6）交接：商家将商品退还给客户，返修完成。

二、售后服务流程
    售后服务的流程如下图所示，大致分为以下几个步骤：
（1）分配任务：商家在接到客户的服务请求之后，将售后服务的任务分配给技术员；
（2）执行任务：技术员在接到任务之后，为客户提供服务，执行之后填写任务执行情况；
（3）回访：主管视需要对技术员的服务进行回访或抽查；
（4）评分：主管对技术员的任务执行情况进行评分。

三、数据结构
    有了流程之后，我们需要设计网站的数据结构。这个小项目用到的数据结构比较简单，没什么好说的，大家可以自行到SqlServer企业管理器中去查看，我对每个字段、表、存储过程都有详细的注释。下载部分提供了数据库文件及日志文件，直接在SqlServer企业管理器中附加数据库就可以了。
四、所用的技术
    本网站使用了以下技术：
（1）数据库：Sql Server；
（2）后台：C#、asp.net；
（3）前台：jQuery、AutoComplete、My97DatePicker。
五、获取源码及文档
    您可以到我老婆的淘宝网店去获取源码及文档：
：点击进入网店
：点击直接打开获取源码页面
    我知道这样做不太好，我很内疚，但是没办法，我希望能帮老婆一把，希望大家体谅：
（1）获取整站源码及文档近乎免费，仅需要0.1元，如果您觉得太贵，可以联系我将金额修改为最低限额0.02元；
（2）您支付的金额将全部捐赠至“中国绿化基金会”；（该商品设定为100%捐赠，如果您有余钱且有爱心，可以主动要求多付款 ~_~ ）
（3）如果您正好没有支付宝帐号，您可以到网店留言并写上您的电子邮件地址，我也会免费发给您；
（4）老婆的网店初创，需要提高点人气 -_- 。

本文链接

源代码下载

2010-12-20T08:25:00Z

作者：王先荣(Xianrong Wang)

下面是我的一些源代码：

1. 图像处理学习系列源代码——包括该系列文章的几乎所有代码；

1.5. 图像处理学习系列中用到的dll文件包——将这个解压缩之后放到Debug或者Release目录中；

2. OpenCV2.1的新特征；

3. 直方图；

4. 非参数背景生成；

5. 特征检测；

代码写得丑陋，请见谅。

注：仅供学习研究，未经许可，不得用于商业目的。

本文链接

解决EPSON R230打印机驱动程序安装错误

2010-11-02T01:14:00Z

作者：王先荣

今天在一台电脑上安装EPSON R230打印机驱动程序时，提示："UI DLL Message ---Version error dat file. Please install again."，反复安装总是失败。大致有以下现象：（1）打印机和传真中没有该型号的打印机；（2）设备管理器中有隐藏的"EPSON STYLUS R230"打印机。

如果重新安装系统之后，应该能够安装上驱动程序；但是这台电脑乱七八糟的软件太多，重新安装起来太麻烦。后面虽然搞定，却颇费周折。

现将我所发现的解决步骤记录如下：

（1）在控制面板的添加删除程序中，删除以EPSON开始的一系列打印相关软件；在“爱普生打印工具”中删除临时文件和R230打印机；关闭打印机电源，然后重新启动电脑；

（2）在控制面板的打印机和传真中，点击菜单“文件->服务器属性”，在“打印服务器属性”窗口中切换到“驱动程序页”，选中EPSON开始的那项，然后将其删除；重新启动电脑；

（3）重新安装驱动程序。

前前后后花费了两个小时，记录下来希望能帮助到更多的人。

本文链接

OpenCV(EmguCV)2.1新特性介绍之图像差异StereoSGBM与设置窗口属性SetWindowProperty(StereoSGBM Of OpenCV 2.1)

2010-04-29T01:33:00Z

作者：王先荣

    上次介绍了OpenCV2.1中新增的图像分割算法GrabCut，本文将介绍StereoSGBM与SetWindowProperty。其中StereoSGBM用于计算两幅图像间的差异图，跟已有的StereoBM和StereoGC作用一样，算法不同而已；SetWindowProperty用于设置窗口的属性，目前仅可用于设置全屏属性。

比较图像间的差异StereoSGBM
    StereoSGBM用于计算两幅图像间的差异图，在OpenCV的在线文档中有非常详细的介绍，地址是：“http://opencv.willowgarage.com/documentation/cpp/camera_calibration_and_3d_reconstruction.html#stereosgbm”。参数非常多，如果不使用默认的参数，需要仔细查看每个参数的说明，以免出错。OpenCV的具体实现在命名空间cv中的StereoSGBM类，目前还没有对应的C风格封装；EmguCV将其封装在StereoSGBM类中。
    StereoSGBM除了参数很多之外，使用起来蛮简单的，如下所示：

//创建StereoSGBM对象
StereoSGBM sgbm = new StereoSGBM((int)nudMinDisparity.Value, (int)nudNumDisparities.Value, (int)nudSADWindowSize.Value, (int)nudP1.Value,
    (int)nudP2.Value, (int)nudDisp12MaxDiff.Value, (int)nudPreFilterCap.Value, (int)nudUniquenessRatio.Value,
    (int)nudSpeckleWindowSize.Value, (int)nudSpeckleRange.Value, chkFullDP.Checked);
//查找两幅图像间的相关性（差异）
sgbm.FindStereoCorrespondence(leftImage, rightImage, disparityImage);
//显示结果
pbDisparity.Image = disparityImage.Bitmap;
//释放资源
sgbm.Dispose();

完整的示例（附带了StereoBM和StereoGC的示例）请看：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
using System.Runtime.InteropServices;
using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;

namespace NewFeaturesOfOpenCV2._1
{
    public partial class FormStereoCorrespondence : Form
    {
        //私有成员
        private string leftImageFileName = "wky_sls_2272x1704.jpg";     //左边的图像文件名
        private string rightImageFileName = "wky_sls_2272x1704_2.jpg";  //右边的图像文件名
        private Image<Gray, Byte> leftImage = null;                     //左边的灰度图像
        private Image<Gray, Byte> rightImage = null;                    //右边的灰度图像
        private Image<Gray, Int16> disparityImage = null;               //差异图像
        private Stopwatch sw = new Stopwatch();                         //计时器

        public FormStereoCorrespondence()
        {
            InitializeComponent();
        }

        //设置SGBM的默认参数
        private void btnFillDefaultParameters_Click(object sender, EventArgs e)
        {
            nudSADWindowSize.Value = 3;
            nudP1.Value = 0;
            nudP2.Value = 0;
            nudDisp12MaxDiff.Value = 0;
            nudPreFilterCap.Value = 0;
            nudUniquenessRatio.Value = 0;
            nudSpeckleWindowSize.Value = 0;
            nudSpeckleRange.Value = 0;
            chkFullDP.Checked = false;
        }

        //设置SGBM的推荐参数
        private void btnFillRecommendedParameters_Click(object sender, EventArgs e)
        {
            nudUniquenessRatio.Value = 5;
            nudSpeckleWindowSize.Value = 50;
            nudSpeckleRange.Value = 16;
        }

        //窗体加载时
        private void FormStereoCorrespondence_Load(object sender, EventArgs e)
        {
            //设置提示
            toolTip.SetToolTip(nudNumDisparities, "必须大于0，且能被16除尽");
            toolTip.SetToolTip(nudSADWindowSize, "缺省为0；如果指定则必须是正奇数，推荐值为3～11");
            toolTip.SetToolTip(nudP1, "缺省为0；推荐值为8*number_of_image_channels*SADWindowSize*SADWindowSize");
            toolTip.SetToolTip(nudP2, "缺省为0；如果指定则P2>P1，推荐值为32*number_of_image_channels*SADWindowSize*SADWindowSize");
            toolTip.SetToolTip(nudDisp12MaxDiff, "如果设置为负值，则跳过左右差异检查");
            toolTip.SetToolTip(nudUniquenessRatio, "缺省为0，推荐值为5～15");
            toolTip.SetToolTip(nudSpeckleWindowSize, "缺省为0，推荐值为50～200");
            toolTip.SetToolTip(nudSpeckleRange, "缺省为0；如果指定则必须是能被16整除的正数，推荐值为16或者32");
            //初始化图像
            InitImage(true);
            InitImage(false);
        }

        //加载图像1
        private void btnLoadLeftImage_Click(object sender, EventArgs e)
        {
            LoadImage(true);
        }

        //加载图像2
        private void btnLoadRightImage_Click(object sender, EventArgs e)
        {
            LoadImage(false);
        }

        /// <summary>
        /// 加载图像
        /// </summary>
        /// <param name="isLeft">是左边的图像吗？</param>
        private void LoadImage(bool isLeft)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            ofd.CheckFileExists = true;
            ofd.DefaultExt = "jpg";
            ofd.Filter = "图片文件|*.jpg;*.png;*.bmp|所有文件|*.*";
            if (ofd.ShowDialog(this) == DialogResult.OK)
            {
                if (ofd.FileName != "")
                {
                    if (isLeft)
                        leftImageFileName = ofd.FileName;
                    else
                        rightImageFileName = ofd.FileName;
                    InitImage(isLeft);
                }
            }
            ofd.Dispose();
        }

        /// <summary>
        /// 初始化图像
        /// </summary>
        /// <param name="isLeft">是左边的图像吗？</param>
        private void InitImage(bool isLeft)
        {
            if (isLeft)
            {
                Image<Bgr, Byte> image = new Image<Bgr, byte>(leftImageFileName);
                pbLeft.Image = image.Bitmap;
                if (leftImage != null)
                    leftImage.Dispose();
                leftImage = image.Convert<Gray, Byte>();
                if (disparityImage != null)
                    disparityImage.Dispose();
                disparityImage = new Image<Gray, short>(leftImage.Size);
                image.Dispose();
            }
            else
            {
                Image<Bgr, Byte> image = new Image<Bgr, byte>(rightImageFileName);
                pbRight.Image = image.Bitmap;
                if (rightImage != null)
                    rightImage.Dispose();
                rightImage = image.Convert<Gray, Byte>();
                image.Dispose();
            }
        }

        //开始计算
        private void btnCalc_Click(object sender, EventArgs e)
        {
            if (leftImage.Size != rightImage.Size)
            {
                MessageBox.Show(this, "两幅图像的尺寸不一致，不能比较。", "错误提示");
                return;
            }
            if (tcStereo.SelectedTab == tpStereoSGBM)
            {
                StereoSGBM sgbm = new StereoSGBM((int)nudMinDisparity.Value, (int)nudNumDisparities.Value, (int)nudSADWindowSize.Value, (int)nudP1.Value,
                    (int)nudP2.Value, (int)nudDisp12MaxDiff.Value, (int)nudPreFilterCap.Value, (int)nudUniquenessRatio.Value,
                    (int)nudSpeckleWindowSize.Value, (int)nudSpeckleRange.Value, chkFullDP.Checked);
                sw.Stop();
                sw.Start();
                sgbm.FindStereoCorrespondence(leftImage, rightImage, disparityImage);
                sw.Stop();
                pbDisparity.Image = disparityImage.Bitmap;
                sgbm.Dispose();
                lblStatus.Text = string.Format("SGBM比较耗时{0:F04}毫秒。", sw.ElapsedMilliseconds);
            }
            else if (tcStereo.SelectedTab == tpStereoBM)
            {
                STEREO_BM_TYPE type = cbBMType.Text == "BASIC" ? STEREO_BM_TYPE.BASIC : (cbBMType.Text == "FISH_EYE" ? STEREO_BM_TYPE.FISH_EYE : STEREO_BM_TYPE.NARROW);
                StereoBM bm = new StereoBM(type, (int)nudBMNumberOfDisparities.Value);
                sw.Stop();
                sw.Start();
                bm.FindStereoCorrespondence(leftImage, rightImage, disparityImage);
                sw.Stop();
                pbDisparity.Image = disparityImage.Bitmap;
                bm.Dispose();
                lblStatus.Text = string.Format("BM比较耗时{0:F04}毫秒。", sw.ElapsedMilliseconds);
            }
            else if (tcStereo.SelectedTab == tpStereoGC)
            {
                StereoGC gc = new StereoGC((int)nudGCNumberOfDisparities.Value, (int)nudGCMaxIters.Value);
                Image<Gray, Int16> rightDisparityImage = new Image<Gray, short>(leftImage.Size);
                sw.Stop();
                sw.Start();
                gc.FindStereoCorrespondence(leftImage, rightImage, disparityImage, rightDisparityImage);
                sw.Stop();
                CvInvoke.cvConvertScale(rightDisparityImage.Ptr, rightDisparityImage.Ptr, 16d, 0d);
                CvInvoke.cvConvertScale(disparityImage.Ptr, disparityImage.Ptr, -16d, 0d);
                pbDisparity.Image = rightDisparityImage.Bitmap;
                rightDisparityImage.Dispose();
                gc.Dispose();
                lblStatus.Text = string.Format("GC比较耗时{0:F04}毫秒。", sw.ElapsedMilliseconds);
            }
        }

        //关闭窗口时
        private void FormStereoCorrespondence_FormClosed(object sender, FormClosedEventArgs e)
        {
            //释放资源
            if (leftImage != null)
                leftImage.Dispose();
            if (rightImage != null)
                rightImage.Dispose();
            if (disparityImage != null)
                disparityImage.Dispose();
        }
    }
}

设置窗口属性SetWindowProperty
    目前只能用SetWindowProperty来设置窗口的全屏属性——全屏或者普通窗口。其实OpenCV2.1中还增加了一个名为cvGetWindowProperty的函数，用于获取窗口的属性，更新说明中没有提到而已。由于目前还没有这个函数的相关文档，我就详细点说说。
1.函数原型、参数说明及提示
void cvSetWindowProperty(const char* name, int prop_id, double prop_value)
作用：设置窗口的属性
返回值：无
参数：
name——窗口名称，对应于用cvNamedWindow创建窗口时使用的名称；
prop_id——属性id，目前有两种属性：CV_WND_PROP_FULLSCREEN   （=0）和CV_WND_PROP_AUTOSIZE（=1），但是仅CV_WND_PROP_FULLSCREEN有用；
prop_value——属性值，如果设置全屏属性，则该值可能有：CV_WINDOW_NORMAL（=0）和CV_WINDOW_FULLSCREEN   （=1）。
备注：（1）cvSetWindowProperty目前只能用于设置窗口的全屏属性；（2）在设置该属性前，要求窗口不能是AUTOSIZE的，否则设置无效；（3）基于第2点原因，在创建窗口时不能省略flag参数（即不能使用其默认值CV_WINDOW_AUTOSIZE）；（4）由于EmguCV封装的CvInvoke.cvNamedWindow强制使用了AUTOSIZE参数，因此不能使用它来创建窗口，需要自行进行P/Invoke调用；（5）OpenCV2.1更新文档中的使用示例是错误的，不要模仿。

double cvGetWindowProperty(const char* name, int prop_id)
作用：获取窗口的属性
返回值：返回窗口的属性值
参数：同cvSetWindowProperty

2.示例
您可以按如下所示使用cvSetWindowProperty：

cvSetWindowProperty(windowName, CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);

完整的示例请看：

        //全屏窗口
        private void btnSetWindowProperty_Click(object sender, EventArgs e)
        {
            Image<Bgr, Byte> image = new Image<Bgr, byte>("wky_qiao_2272x1704.jpg");
            string windowName = "stereoGC left disparity";
            cvNamedWindow(windowName, 0);
            cvResizeWindow(windowName, 640, 480);
            cvMoveWindow(windowName, 100, 100);
            cvSetWindowProperty(windowName, CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);
            CvInvoke.cvShowImage(windowName, image.Ptr);
            CvInvoke.cvWaitKey(0);
            CvInvoke.cvDestroyWindow(windowName);
            image.Dispose();
        }

        //定义跟窗口相关的常量
        public const int CV_WND_PROP_FULLSCREEN = 0;
        public const int CV_WND_PROP_AUTOSIZE = 1;
        public const double CV_WINDOW_NORMAL = 0;
        public const double CV_WINDOW_FULLSCREEN = 1;
        public const int CV_WINDOW_AUTOSIZE = 1;
        //跟窗口有关的P/Invoke调用
        //设置窗口属性，目前只能设置CV_WND_PROP_FULLSCREEN
        [System.Runtime.InteropServices.DllImportAttribute("highgui210.dll", EntryPoint = "cvSetWindowProperty")]
        public static extern void cvSetWindowProperty([System.Runtime.InteropServices.InAttribute()] [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPStr)] string name, int prop_id, double prop_value);
        //调整窗口的尺寸
        [System.Runtime.InteropServices.DllImportAttribute("highgui210.dll", EntryPoint = "cvResizeWindow")]
        public static extern void cvResizeWindow([System.Runtime.InteropServices.InAttribute()] [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPStr)] string name, int width, int height);
        //移动窗口
        [System.Runtime.InteropServices.DllImportAttribute("highgui210.dll", EntryPoint = "cvMoveWindow")]
        public static extern void cvMoveWindow([System.Runtime.InteropServices.InAttribute()] [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPStr)] string name, int x, int y);
        //创建指定名称的窗口
        [System.Runtime.InteropServices.DllImportAttribute("highgui210.dll", EntryPoint = "cvNamedWindow")]
        public static extern int cvNamedWindow([System.Runtime.InteropServices.InAttribute()] [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPStr)] string name, int flags);
        //获取窗口对应的句柄HWnd
        [System.Runtime.InteropServices.DllImportAttribute("highgui210.dll", EntryPoint = "cvGetWindowHandle")]
        public static extern System.IntPtr cvGetWindowHandle([System.Runtime.InteropServices.InAttribute()] [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPStr)] string name);
        //获取指定句柄对应的窗口名称
        [System.Runtime.InteropServices.DllImportAttribute("highgui210.dll", EntryPoint = "cvGetWindowName")]
        public static extern System.IntPtr cvGetWindowName(System.IntPtr windowHandle);
        //获取窗口的属性
        [System.Runtime.InteropServices.DllImportAttribute("highgui210.dll", EntryPoint = "cvGetWindowProperty")]
        public static extern double cvGetWindowProperty([System.Runtime.InteropServices.InAttribute()] [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPStr)] string name, int prop_id);

    }

感谢您耐心看完本文，希望对您有所帮助。
欢迎转载，但是请注明出处，保留作者。

本文链接

OpenCV(EmguCV)2.1新特性介绍之图像分割GrabCut(GrabCut Of OpenCV 2.1)

2010-04-27T07:00:00Z

作者：王先荣
前不久OpenCV和EmguCV相继发布了2.1版，增加了一些新的特性，本文关注的是其中的图像分割部分——GrabCut。GrabCut主要用于图像编辑中的抠图，作用跟Photoshop中的魔法棒、套索类似，但是更加强大。由于没有GrabCut的文档，探索具体的用法花费了不少时间和精力，仔细看了论文，大致看了源代码。

GrabCut简介
OpenCV中的GrabCut算法是依据《"GrabCut" - Interactive Foreground Extraction using Iterated Graph Cuts》这篇文章来实现的。该算法利用了图像中的纹理（颜色）信息和边界（反差）信息，只要少量的用户交互操作即可得到比较好的分割结果。如果前景和背景之间的颜色反差不大，分割的效果不好；不过，这种情况下允许手工标记一些前景或背景区域，这样能得到较好的结果。经我测试，GrabCut算法的效率不高，初始化341x326大小的矩形窗大约需要20秒，处理需要9秒；而论文中宣称初始化450x300大小的矩形窗仅0.9秒，处理只要0.12秒；虽然矩形大小和测试环境稍有区别，但是结果却相差太多。

GrabCut函数说明
函数原型：
    void cv::grabCut( const Mat& img, Mat& mask, Rect rect,
             Mat& bgdModel, Mat& fgdModel,
             int iterCount, int mode )
其中：
img——待分割的源图像，必须是8位3通道（CV_8UC3）图像，在处理的过程中不会被修改；
mask——掩码图像，如果使用掩码进行初始化，那么mask保存初始化掩码信息；在执行分割的时候，也可以将用户交互所设定的前景与背景保存到mask中，然后再传入grabCut函数；在处理结束之后，mask中会保存结果。mask只能取以下四种值：
GCD_BGD（=0），背景；
GCD_FGD（=1），前景；
GCD_PR_BGD（=2），可能的背景；
GCD_PR_FGD（=3），可能的前景。
如果没有手工标记GCD_BGD或者GCD_FGD，那么结果只会有GCD_PR_BGD或GCD_PR_FGD；
rect——用于限定需要进行分割的图像范围，只有该矩形窗口内的图像部分才被处理；
bgdModel——背景模型，如果为null，函数内部会自动创建一个bgdModel；bgdModel必须是单通道浮点型（CV_32FC1）图像，且行数只能为1，列数只能为13x5；
fgdModel——前景模型，如果为null，函数内部会自动创建一个fgdModel；fgdModel必须是单通道浮点型（CV_32FC1）图像，且行数只能为1，列数只能为13x5；
iterCount——迭代次数，必须大于0；
mode——用于指示grabCut函数进行什么操作，可选的值有：
GC_INIT_WITH_RECT（=0），用矩形窗初始化GrabCut；
GC_INIT_WITH_MASK（=1），用掩码图像初始化GrabCut；
GC_EVAL（=2），执行分割。

GrabCut的用法
您可以按以下方式来使用GrabCut函数：
（1）用矩形窗或掩码图像初始化grabCut；
（2）执行分割；
（3）如果对结果不满意，在掩码图像中设定前景和（或）背景，再次执行分割；
（4）使用掩码图像中的前景或背景信息。

从上述图片中可以看出，用更多的迭代次数，或者更多的用户交互都能得到更好的结果。

示例
下面是一个使用GrabCut进行图像分割的例子，其中用了P/INVOKE形式的CvGrabCut函数，以及封装在Image<TColor,TDepth>类中的GrabCut方法。封装的方法便于使用，但是缺少一些功能，灵活性不足。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
using System.Runtime.InteropServices;
using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;

namespace NewFeaturesOfOpenCV2._1
{
    public partial class FormGrabCut : Form
    {
        //常量
        private static readonly Bgr Blue = new Bgr(255d, 0d, 0d);   //蓝色，用于绘制矩形
        private static readonly Bgr Green = new Bgr(0d, 255d, 0d);  //绿色，用于绘制前景曲线
        private static readonly Bgr Red = new Bgr(0d, 0d, 255d);    //红色，用于绘制背景曲线
        private const int LineWidth = 5;                            //绘制线条的宽度
        private const int GC_BGD = 0;                               //背景标志
        private const int GC_FGD = 1;                               //前景标志
        private const int GC_PR_BGD = 2;                            //可能的背景标志
        private const int GC_PR_FGD = 3;                            //可能的前景标志
        //成员变量
        private string sourceImageFileName = "wky_tms_2272x1704.jpg";//源图像文件名
        private Image<Bgr, Byte> imageSource = null;                //源图像
        private Image<Bgr, Byte> imageSourceClone = null;           //源图像的克隆
        private Image<Gray, Byte> imageMask = null;                 //掩码图像：保存初始化之后的掩码信息及用户绘制的信息
        private Matrix<Single> foregroundModel = null;              //前景模型
        private Matrix<Single> backgroundModel = null;              //背景模型
        private double xScale = 1d;                                 //原始图像与PictureBox在x轴方向上的缩放
        private double yScale = 1d;                                 //原始图像与PictureBox在y轴方向上的缩放
        private Point previousMouseLocation = new Point(-1, -1);    //上次绘制线条时，鼠标所处的位置
        private Rectangle rect;                                     //初始化矩形窗口
        private bool initialized = false;                           //是否已经初始化过GrabCut

        public FormGrabCut()
        {
            InitializeComponent();
        }

        //加载窗体时
        private void FormGrabCut_Load(object sender, EventArgs e)
        {
            //设置提示
            toolTip.SetToolTip(rbRect, "使用鼠标在源图像绘制矩形窗口，在图像分割之前使用矩形窗口所在的区域进行初始化。");
            toolTip.SetToolTip(rbMask, "使用鼠标在源图像绘制掩码，左键绘制前景掩码，邮件绘制背景掩码，在图像分割之前使用掩码图像进行初始化。");
            //初始化前景模型和背景模型
            foregroundModel = new Matrix<float>(1, 13 * 5);
            backgroundModel = new Matrix<float>(1, 13 * 5);
            //加载默认图像
            LoadImage();
        }

        //关闭窗体前，释放资源
        private void FormGrabCut_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (imageSource != null)
                imageSource.Dispose();
            if (imageSourceClone != null)
                imageSourceClone.Dispose();
            if (imageMask != null)
                imageMask.Dispose();
            if (foregroundModel != null)
                foregroundModel.Dispose();
            if (backgroundModel != null)
                backgroundModel.Dispose();
        }

        //加载源图像
        private void btnLoadImage_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            ofd.CheckFileExists = true;
            ofd.DefaultExt = "jpg";
            ofd.Filter = "图片文件|*.jpg;*.png;*.bmp|所有文件|*.*";
            if (ofd.ShowDialog(this) == DialogResult.OK)
            {
                if (ofd.FileName != "")
                {
                    sourceImageFileName = ofd.FileName;
                    LoadImage();
                }
            }
            ofd.Dispose();
        }

        //重新加载图像
        private void btnReload_Click(object sender, EventArgs e)
        {
            LoadImage();
        }

        //加载源图像
        private void LoadImage()
        {
            if (imageSource != null)
                imageSource.Dispose();
            imageSource = new Image<Bgr, byte>(sourceImageFileName);
            if (imageSourceClone != null)
                imageSourceClone.Dispose();
            imageSourceClone = imageSource.Copy();
            pbSource.Image = imageSourceClone.Bitmap;
            if (imageMask != null)
                imageMask.Dispose();
            imageMask = new Image<Gray, byte>(imageSource.Size);
            imageMask.SetZero();
            xScale = 1d * imageSource.Width / pbSource.Width;
            yScale = 1d * imageSource.Height / pbSource.Height;
            rect = new Rectangle(-1, -1, 1, 1);
            initialized = false;
        }

        //鼠标在源图像上按下时
        private void pbSource_MouseDown(object sender, MouseEventArgs e)
        {
            if (rbRect.Checked)
                rect = new Rectangle((int)(e.X * xScale), (int)(e.Y * yScale), 1, 1);
            else
                previousMouseLocation = new Point((int)(e.X * xScale), (int)(e.Y * yScale));
        }

        //鼠标在源图像上移动时
        private void pbSource_MouseMove(object sender, MouseEventArgs e)
        {
            //绘制矩形
            if (rbRect.Checked && e.Button != MouseButtons.None)
            {
                rect = new Rectangle(rect.Left, rect.Top, (int)(e.X * xScale - rect.Left), (int)(e.Y * yScale - rect.Top));
                imageSourceClone.Dispose();
                imageSourceClone = imageSource.Clone();
                imageSourceClone.Draw(rect, Blue, LineWidth);
                pbSource.Image = imageSourceClone.Bitmap;
                return;
            }
            //绘制线条，用于手工标记前景或者背景
            if (rbMask.Checked && (e.Button == MouseButtons.Left || e.Button == MouseButtons.Right))
            {
                if (previousMouseLocation.X == -1 && previousMouseLocation.Y == -1)
                {
                    previousMouseLocation.X = (int)(e.X * xScale);
                    previousMouseLocation.Y = (int)(e.Y * yScale);
                }
                else
                {
                    LineSegment2D line = new LineSegment2D(previousMouseLocation, new Point((int)(e.X * xScale), (int)(e.Y * yScale)));
                    if (e.Button == MouseButtons.Left)
                    {
                        imageMask.Draw(line, new Gray((double)GC_FGD), LineWidth);
                        imageSourceClone.Draw(line, Green, LineWidth);
                    }
                    else
                    {
                        imageMask.Draw(line, new Gray((double)GC_BGD), LineWidth);
                        imageSourceClone.Draw(line, Red, LineWidth);
                    }
                    pbSource.Image = imageSourceClone.Bitmap;
                    previousMouseLocation = line.P2;
                }

            }
        }

        //鼠标在源图像上松开时
        private void pbSource_MouseUp(object sender, MouseEventArgs e)
        {
            if (rbRect.Checked && e.Button != MouseButtons.None)
            {
                rect = new Rectangle(rect.Left, rect.Top, (int)(e.X * xScale - rect.Left), (int)(e.Y * yScale - rect.Top));
                imageSourceClone.Dispose();
                imageSourceClone = imageSource.Clone();
                imageSourceClone.Draw(rect, Blue, LineWidth);
                pbSource.Image = imageSourceClone.Bitmap;
                //绘制矩形结束之后，初始化掩码图像
                imageMask.SetZero();
                imageMask.Draw(rect, new Gray((double)GC_PR_FGD), 0);
                return;
            }
            if (rbMask.Checked)
                previousMouseLocation = new Point(-1, -1);
        }

        //开始图像分割
        private void btnStartSegment_Click(object sender, EventArgs e)
        {
            if (rect != new Rectangle(-1, -1, 1, 1))  //必须指定矩形窗
            {
                Stopwatch sw = new Stopwatch();
                Image<Gray, Byte> mask = null;
                if (rbRect.Checked)
                {
                    //用矩形窗初始化
                    sw.Reset();
                    sw.Start();
                    mask = imageSource.GrabCut(rect, (int)nudIterCount.Value);  //注：Image.GrabCut等价于先用矩形初始化CvGrabCut(....,GRABCUT_INIT_TYPE.INIT_WITH_RECT)，然后再计算CvGrabCut(....,GRABCUT_INIT_TYPE.INIT_WITH_EVAL)
                    sw.Stop();
                    imageMask = mask.Clone();
                    initialized = true;
                    ShowResult("用矩形窗初始化GrabCut并计算", sw.ElapsedMilliseconds);
                }
                else
                {
                    //用掩码初始化
                    mask = imageMask.Clone();
                    if (!initialized)
                    {
                        sw.Reset();
                        sw.Start();
                        CvInvoke.CvGrabCut(imageSource.Ptr, mask.Ptr, ref rect, backgroundModel.Ptr, foregroundModel.Ptr, 1, GRABCUT_INIT_TYPE.INIT_WITH_MASK);
                        sw.Stop();
                        initialized = true;
                        ShowResult("用掩码初始化GrabCut", sw.ElapsedMilliseconds);
                    }
                    sw.Reset();
                    sw.Start();
                    CvInvoke.CvGrabCut(imageSource.Ptr, mask.Ptr, ref rect, backgroundModel.Ptr, foregroundModel.Ptr, (int)nudIterCount.Value, GRABCUT_INIT_TYPE.EVAL);
                    sw.Stop();
                    ShowResult("计算GrabCut", sw.ElapsedMilliseconds);
                }
                CvInvoke.cvAndS(mask.Ptr, new MCvScalar(1d), mask.Ptr, IntPtr.Zero);    //将掩码图像和1进行按位“与”操作，这样背景及可能的背景将变为0；而前景及可能的前景将变成1
                Image<Bgr, Byte> result = imageSource.Copy(mask);
                pbResult.Image = result.Bitmap;
                mask.Dispose();
                //result.Dispose();
            }
            else
                MessageBox.Show(this, "在开始分割之前，请在源图像上绘制一个矩形窗口。", "缺少矩形窗", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }

        /// <summary>
        /// 显示结果
        /// </summary>
        /// <param name="prompt">提示</param>
        /// <param name="elapsedMilliseconds">耗时</param>
        private void ShowResult(string prompt, double elapsedMilliseconds)
        {
            txtResult.Text += string.Format("{0}，耗时：{1:F04}毫秒，参数（矩形窗起点：{2}，大小：{3}X{4}，迭代次数：{5}）。\r\n",
                prompt, elapsedMilliseconds, rect.Location, rect.Width, rect.Height, nudIterCount.Value);
        }
    }
}

点击这里下载本文源代码。

感谢您耐心看完本文，希望对您有所帮助。
欢迎转载，但是请注明出处，保留作者。

本文链接

背景建模与前景检测之三(Background Generation And Foreground Detection Phase 3)

2010-04-12T03:08:00Z

作者：王先荣

在上一篇文章里，我尝试翻译了《Nonparametric Background Generation》，本文主要介绍以下内容：如何实现该论文的算法，如果利用该算法来进行背景建模及前景检测，最后谈谈我的一些体会。为了使描述更加简便，以下将该论文的算法及实现称为NBGModel。
1 使用示例
NBGModel在使用上非常的简便，您可以仿照下面的代码来使用它：

//初始化NBGModel对象
NBGModel nbgModel = new NBGModel(320, 240);
//训练背景模型
nbgModel.TrainBackgroundModel(historyImages);
//前景检测
nbgModel.Update(currentFrame);
//利用结果
pbResult.Image = nbgModel.ForegroundMask.Bitmap;
//释放对象
nbgModel.Dispose();

下面是更加完整的示例：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing.Imaging;
using System.Diagnostics;
using System.Runtime.InteropServices;
using Emgu.CV;
using Emgu.CV.Structure;
using Emgu.CV.CvEnum;
using System.Threading;

namespace ImageProcessLearn
{
    public partial class FormForegroundDetect2 : Form
    {
        //成员变量
        //public const string ImageFilePathName = @"D:\Users\xrwang\Desktop\背景建模与前景检测\PETS2009\Crowd_PETS09\S0\City_Center\Time_12-34\View_001\frame_{0:D4}.jpg";
        public const string ImageFilePathName = @"E:\PETS2009\S0_City_Center\Time_12-34\View_002\frame_{0:D4}.jpg"; //图像文件的路径信息，其中的{xxx}部分需要被实际的索引数字替换
        public const int ImageWidth = 768;                  //图像的宽度
        public const int ImageHeight = 576;                 //图像的高度
        public const int MaxImageFileIndexNumber = 794;     //最大的图像索引数字
        private Action action = Action.Stop;                //当前正在执行的动作
        private NBGModel nbgModel = null;                   //非参数背景模型
        private Thread threadTrainingBackground = null;     //用于训练背景的工作线程
        private Thread threadForegroundDetection = null;    //用于前景检测的工作线程

        public FormForegroundDetect2()
        {
            InitializeComponent();
        }

        //开始训练背景
        private void btnStartTrainingBackground_Click(object sender, EventArgs e)
        {
            threadTrainingBackground = new Thread(new ThreadStart(TrainingBackground));
            threadTrainingBackground.Start();
            action = Action.StartTrainingBackground;
            SetButtonState();
        }

        //训练背景
        private void TrainingBackground()
        {
            //构造非参数背景模型对象
            if (nbgModel != null)
                nbgModel.Dispose();
            NBGParameter param = (NBGParameter)this.Invoke(new GetNBGParameterDelegate(GetNBGParameter));
            nbgModel = new NBGModel(ImageWidth, ImageHeight, param);            
            //添加用于训练的图像
            for (int idx = 0; idx < param.n; idx++)
            {
                if (action != Action.StartTrainingBackground)
                    return;
                Image<Bgr, Byte> image = new Image<Bgr, byte>(string.Format(ImageFilePathName, idx));
                nbgModel.AddHistoryImage(image);
                this.Invoke(new ShowTrainingBackgroundImageDelegate(ShowTrainingBackgroundImage),
                    new object[] { image.Bitmap, idx });
                image.Dispose();
            }
            //训练背景
            Stopwatch sw = new Stopwatch();
            sw.Start();
            nbgModel.TrainBackgroundModel();
            sw.Stop();
            //显示结果
            this.Invoke(new ShowTrainingBackgroundResultDelegate(ShowTrainingBackgroundResult),
                new object[]{ nbgModel.Mrbm.Bitmap,string.Format("NBGModel训练背景用时{0:F04}毫秒，参数（样本数目：{1}，典型点数目：{2}）。",sw.ElapsedMilliseconds,param.n,param.m)});
        }

        //用于在训练背景工作线程中获取设置参数的委托及方法
        private delegate NBGParameter GetNBGParameterDelegate();
        private NBGParameter GetNBGParameter()
        {
            return new NBGParameter((int)nudNBGModelN.Value, (int)nudNBGModelM.Value, (double)nudNBGModelTheta.Value, (double)nudNBGModelT.Value, new MCvTermCriteria((int)nudNBGModelMaxIter.Value, (double)nudNBGModelEps.Value));
        }

        //用于在训练背景工作线程中显示结果的委托及方法
        private delegate void ShowTrainingBackgroundResultDelegate(Bitmap mrbm, string result);
        private void ShowTrainingBackgroundResult(Bitmap mrbm, string result)
        {
            pbResult.Image = mrbm;
            txtResult.Text += result + "\r\n";
            action = Action.Stop;
            SetButtonState();
        }

        //用于在训练背景工作线程中显示训练图像的委托及方法
        private delegate void ShowTrainingBackgroundImageDelegate(Bitmap bitmap, int idx);
        private void ShowTrainingBackgroundImage(Bitmap bitmap, int idx)
        {
            pbSource.Image = bitmap;
            lblImageIndex.Text = string.Format("{0:D4}", idx);
        }

        //开始前景检测
        private void btnStartForegroundDetection_Click(object sender, EventArgs e)
        {
            threadForegroundDetection = new Thread(new ThreadStart(ForegroundDetection));
            threadForegroundDetection.Start();
            action = Action.StartForegroundDetection;
            SetButtonState();
        }

        //检测前景
        private void ForegroundDetection()
        {
            if (nbgModel == null)
                return;
            Stopwatch sw = new Stopwatch();
            int idx;
            for (idx = nbgModel.Param.n; idx < MaxImageFileIndexNumber; idx++)
            {
                if (action != Action.StartForegroundDetection)
                    break;
                if ((idx - nbgModel.Param.n) % 50 == 49)
                    nbgModel.ClearStale(40);
                Image<Bgr, Byte> image = new Image<Bgr, byte>(string.Format(ImageFilePathName, idx));
                sw.Start();
                nbgModel.Update(image);
                sw.Stop();
                Image<Bgr, Byte> imageForground = image.Copy(nbgModel.ForegroundMask);
                this.Invoke(new ShowForegroundDetectionImageDelegate(ShowForegroundDetectionImage),
                    new object[] { image.Bitmap, imageForground.Bitmap, idx });
                image.Dispose();
                imageForground.Dispose();
            }
            int frames = idx - nbgModel.Param.n;
            this.Invoke(new ShowForegroundDetectionResultDelegate(ShowForegroundDetectionResult),
                new object[] { string.Format("NBGModel前景检测，共{0}帧，平均耗时{1:F04}毫秒，参数（样本数目：{2}，典型点数目：{3}，权重系数：{4}，最小差值：{5}，最大迭代次数：{6}，终止精度：{7}）",
                frames,1d*sw.ElapsedMilliseconds/frames,nbgModel.Param.n,nbgModel.Param.m,nbgModel.Param.theta,nbgModel.Param.t,nbgModel.Param.criteria.max_iter,nbgModel.Param.criteria.epsilon)});
        }

        //用于在前景检测工作线程中显示图像的委托及方法
        private delegate void ShowForegroundDetectionImageDelegate(Bitmap image, Bitmap foreground, int idx);
        private void ShowForegroundDetectionImage(Bitmap image, Bitmap foreground, int idx)
        {
            pbSource.Image = image;
            pbResult.Image = foreground;
            lblImageIndex.Text = string.Format("{0:D4}", idx);
        }

        //用于在前景检测工作线程中显示结果的委托及方法
        private delegate void ShowForegroundDetectionResultDelegate(string result);
        private void ShowForegroundDetectionResult(string result)
        {
            txtResult.Text += result;
        }

        //停止
        private void btnStop_Click(object sender, EventArgs e)
        {
            if (action == Action.StartTrainingBackground)
            {
                action = Action.Stop;
                Thread.Sleep(1);
                if (threadTrainingBackground.ThreadState == System.Threading.ThreadState.Running)
                    threadTrainingBackground.Abort();
                nbgModel.Dispose();
                nbgModel = null;
            }
            action = Action.Stop;
            SetButtonState();
        }

        /// <summary>
        /// 设置按钮的状态
        /// </summary>
        private void SetButtonState()
        {
            if (action == Action.Stop)
            {
                btnStartTrainingBackground.Enabled = true;
                btnStartForegroundDetection.Enabled = true;
                btnStop.Enabled = false;
            }
            else if (action == Action.StartForegroundDetection || action==Action.StartTrainingBackground)
            {
                btnStartTrainingBackground.Enabled = false;
                btnStartForegroundDetection.Enabled = false;
                btnStop.Enabled = true;
            }
        }

        //加载窗体时
        private void FormForegroundDetect2_Load(object sender, EventArgs e)
        {
            toolTip.SetToolTip(nudNBGModelN, "样本数目：需要被保存的历史图像数目");
            toolTip.SetToolTip(nudNBGModelM, "典型点数目：历史图像需要被分为多少组");
            toolTip.SetToolTip(nudNBGModelTheta, "权重系数：权重大于该值的聚集中心是候选背景");
            toolTip.SetToolTip(nudNBGModelT, "最小差值：观测值与聚集中心的最小差值如果大于该值，为前景；否则为背景");
            toolTip.SetToolTip(nudNBGModelMaxIter, "最大迭代次数：MeanShift计算过程中的最大迭代次数");
            toolTip.SetToolTip(nudNBGModelEps, "终止精度：MeanShift计算过程中，如果矩形窗的位移小于等于该值，则停止计算");

            pbSource.Image = Image.FromFile(string.Format(ImageFilePathName, 0));
            lblImageIndex.Text = string.Format("{0:D4}", 0);
        }

        //当窗体关闭后，释放资源
        private void FormForegroundDetect2_FormClosed(object sender, FormClosedEventArgs e)
        {
            if (threadTrainingBackground != null && threadTrainingBackground.ThreadState == System.Threading.ThreadState.Running)
                threadTrainingBackground.Abort();
            if (threadForegroundDetection != null && threadForegroundDetection.ThreadState == System.Threading.ThreadState.Running)
                threadForegroundDetection.Abort();
            if (nbgModel != null)
                nbgModel.Dispose();
        }
    }

    /// <summary>
    /// 当前正在执行的动作
    /// </summary>
    public enum Action
    {
        StartTrainingBackground,    //开始训练背景
        StartForegroundDetection,   //开始前景检测
        Stop                        //停止
    }
}

2 实现NBGModel
2.1 我在实现NBGModel的时候基本上跟论文中的方式一样，不过有以下两点区别：
（1）论文中的MeanShift计算使用了Epanechnikov核函数，我使用的是矩形窗形式的MeanShift计算。主要是因为我自己不会实现MeanShift，只能利用OpenCV中提供的cvMeanShift函数。这样做也有一个好处——不再需要计算与保存典型点。
（2）论文中的方法在检测的过程中聚集中心会不断的增加，我模仿CodeBook的实现为其增加了一个清除消极聚集中心的ClearStable方法。这样可以在必要的时候将长期不活跃的聚集中心清除掉。

2.2 NBGModel中用到的数据成员如下所示：
        private int width;                                          //图像的宽度
        private int height;                                         //图像的高度
        private NBGParameter param;                                 //非参数背景模型的参数

private List<Image<Ycc, Byte>> historyImages = null;        //历史图像：列表个数为param.n，在更新时如果个数大于等于param.n，删除最早的历史图像，加入最新的历史图像
        //由于这里采用矩形窗口方式的MeanShift计算，因此不再需要分组图像的典型点。这跟论文不一样。
        //private List<Image<Ycc,Byte>> convergenceImages = null;   //收敛图像：列表个数为param.m，仅在背景训练时使用，训练结束即被清空，因此这里不再声明
        private Image<Gray, Byte> sampleImage = null;               //样本图像：保存历史图像中每个像素在Y通道的值，用于MeanShift计算
        private List<ClusterCenter<Ycc>>[,] clusterCenters = null; //聚集中心数据：将收敛点分类之后得到的聚集中心，数组大小为：height x width，列表元素个数不定q（q<=m）。
        private Image<Ycc, Byte> mrbm = null;                       //最可靠背景模型

private Image<Gray, Byte> backgroundMask = null; //背景掩码图像

private double frameCount = 0; //总帧数（不包括训练阶段的帧数n）

其中，NBGParameter结构包含以下成员：
        public int n;                       //样本数目：需要被保留的历史图像数目
        public int m;                       //典型点数目：历史图像需要被分为多少组
        public double theta;                //权重系数：权重大于该值的聚集中心为候选背景
        public double t;                    //最小差值：观测值与候选背景的最小差值大于该值时，为前景；否则为背景
        public MCvTermCriteria criteria;    //Mean Shift计算的终止条件：包括最大迭代次数和终止计算的精度

聚集中心ClusterCenter使用类而不是结构，是为了方便更新，它包含以下成员：
        public TColor ci;              //聚集中心的像素值
        public double wi;              //聚集中心的权重
        public double li;              //聚集中心包含的收敛点数目
        public double updateFrameNo;   //更新该聚集中心时的帧数：用于清除消极的聚集中心

2.3 NBGModel中的关键流程
1.背景建模
（1）将训练用的样本图像添加到历史图像historyImages中；
（2）将历史图像分为m组，以每组所在位置的矩形窗为起点进行MeanShift计算，结果窗的中点为收敛中心，收敛中心的像素值为收敛值，将收敛值添加到收敛图像convergenceImages中；
（3）计算收敛图像的聚集中心：（a）得到收敛中心的最小值Cmin；（b）将[0,Cmin+t]区间中的收敛中心划分为一类；（c）计算已分类收敛中心的平均值，作为聚集中心的值；（d）删除已分类的收敛中心；（e）重复a～d，直到收敛中心全部归类；
（4）得到最可靠背景模型MRBM：在聚集中心中选取wi最大的值作为某个像素的最可靠背景。

2.前景检测
（1）用wi≥theta作为条件选择可能的背景组Cb；
（2）对每个观测值x0，计算x0与Cb的最小差值d；
（3）如果d>t，则该点为前景；否则为背景。

3.背景维持
（1）如果某点为背景，更新最近聚集中心的wi为(li+1)/m；
（2）如果某点为前景：（a）以该点所在的矩形窗为起点进行MeanShift计算，可得到新的收敛中心Cnew（wi=1/m)；（b）将Cnew加入到聚集中心clusterCenters；
（3）在必要的时候，清理消极的聚集中心。

2.4 NBGModel的实现代码
值得注意的是：在实现代码中，有好几个以2结尾的私有方法，它们主要用于演示算法流程，实际上并未使用。为了优化性能而增加了不少指针操作之后的代码可读性变得很差。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
using System.Diagnostics;
using System.Runtime.InteropServices;
using Emgu.CV;
using Emgu.CV.Structure;
using Emgu.CV.CvEnum;

namespace ImageProcessLearn
{
    public class NBGModel : IDisposable
    {
        //成员变量
        private int width;                                          //图像的宽度
        private int height;                                         //图像的高度
        private NBGParameter param;                                 //非参数背景模型的参数

        private List<Image<Ycc, Byte>> historyImages = null;        //历史图像：列表个数为param.n，在更新时如果个数大于param.n，删除最早的历史图像，加入最新的历史图像
        //由于这里采用矩形窗口方式的MeanShift计算，因此不再需要分组图像的典型点。这跟论文不一样。
        //private List<Image<Ycc,Byte>> convergenceImages = null;   //收敛图像：列表个数为param.m，仅在背景训练时使用，训练结束即被清空，因此这里不再声明
        private Image<Gray, Byte> sampleImage = null;               //样本图像：保存历史图像中每个像素在Y通道的值，用于MeanShift计算
        private List<ClusterCenter<Ycc>>[,] clusterCenters = null;  //聚集中心数据：将收敛点分类之后得到的聚集中心，数组大小为：height x width，列表元素个数不定q（q<=m）。
        private Image<Ycc, Byte> mrbm = null;                       //最可靠背景模型

        private Image<Gray, Byte> backgroundMask = null;            //背景掩码图像

        private double frameCount = 0;                              //总帧数（不包括训练阶段的帧数n）

        //属性
        /// <summary>
        /// 图像的宽度
        /// </summary>
        public int Width
        {
            get
            {
                return width;
            }
        }

        /// <summary>
        /// 图像的高度
        /// </summary>
        public int Height
        {
            get
            {
                return height;
            }
        }

        /// <summary>
        /// 非参数背景模型的参数
        /// </summary>
        public NBGParameter Param
        {
            get
            {
                return param;
            }
        }

        /// <summary>
        /// 最可靠背景模型
        /// </summary>
        public Image<Ycc, Byte> Mrbm
        {
            get
            {
                return mrbm;
            }
        }

        /// <summary>
        /// 背景掩码
        /// </summary>
        public Image<Gray, Byte> BackgroundMask
        {
            get
            {
                return backgroundMask;
            }
        }

        /// <summary>
        /// 前景掩码
        /// </summary>
        public Image<Gray, Byte> ForegroundMask
        {
            get
            {
                return backgroundMask.Not();
            }
        }

        /// <summary>
        /// 总帧数
        /// </summary>
        public double FrameCount
        {
            get
            {
                return frameCount;
            }
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="width">图像宽度</param>
        /// <param name="height">图像高度</param>
        public NBGModel(int width, int height)
            : this(width, height, NBGParameter.GetDefaultNBGParameter())
        {
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="width">图像宽度</param>
        /// <param name="height">图像高度</param>
        ///<param name="param">非参数背景模型的参数</param>
        public NBGModel(int width, int height, NBGParameter param)
        {
            CheckParameters(width, height, param);
            this.width = width;
            this.height = height;
            this.param = param;

            historyImages = new List<Image<Ycc, byte>>(param.n);
            sampleImage = new Image<Gray, byte>(param.n, 1);
            clusterCenters = new List<ClusterCenter<Ycc>>[height, width];
            for (int row = 0; row < height; row++)
            {
                for (int col = 0; col < width; col++)
                    clusterCenters[row, col] = new List<ClusterCenter<Ycc>>(param.m);   //聚集中心列表不定长，因此将其初始化为m个元素的容量
            }
            mrbm = new Image<Ycc, byte>(width, height);
            backgroundMask = new Image<Gray, byte>(width, height);
            frameCount = 0;
        }

        /// <summary>
        /// 检查参数是否正确，如果不正确，抛出异常
        /// </summary>
        /// <param name="width">图像宽度</param>
        /// <param name="height">图像高度</param>
        /// <param name="param">非参数背景模型的参数</param>
        private void CheckParameters(int width, int height, NBGParameter param)
        {
            if (width <= 0)
                throw new ArgumentOutOfRangeException("width", width, "图像宽度必须大于零。");
            if (height <= 0)
                throw new ArgumentOutOfRangeException("height", height, "图像高度必须大于零。");
            if (param.n <= 0)
                throw new ArgumentOutOfRangeException("n", param.n, "样本数目必须大于零。");
            if (param.m <= 0)
                throw new ArgumentOutOfRangeException("m", param.m, "典型点数目必须大于零。");
            if (param.n % param.m != 0)
                throw new ArgumentException("样本数目必须是典型点数目的整数倍。", "n,m");
            if (param.theta <= 0 || param.theta > 1)
                throw new ArgumentOutOfRangeException("theta", param.theta, "权重系数必须大于零，并且小于1。");
            if (param.t <= 0)
                throw new ArgumentOutOfRangeException("t", param.t, "最小差值必须大于零。");
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            if (historyImages != null && historyImages.Count > 0)
            {
                foreach (Image<Ycc, byte> historyImage in historyImages)
                {
                    if (historyImage != null)
                        historyImage.Dispose();
                }
            }
            if (sampleImage != null)
                sampleImage.Dispose();
            if (clusterCenters != null && clusterCenters.Length > 0)
            {
                foreach (List<ClusterCenter<Ycc>> clusterCentersElement in clusterCenters)
                    clusterCentersElement.Clear();
            }
            if (mrbm != null)
                mrbm.Dispose();
            if (backgroundMask != null)
                backgroundMask.Dispose();
        }

        /// <summary>
        /// 增加历史图像
        /// </summary>
        /// <param name="historyImage">历史图像</param>
        /// <returns>是否增加成功</returns>
        public bool AddHistoryImage(Image<Ycc, byte> historyImage)
        {
            bool success = false;
            if (historyImage != null && historyImage.Width == width && historyImage.Height == height)
            {
                if (historyImages.Count >= param.n)
                {
                    if (historyImages[0] != null)
                        historyImages[0].Dispose();
                    historyImages.RemoveAt(0);
                }
                historyImages.Add(historyImage.Copy());
                success = true;
            }
            return success;
        }

        /// <summary>
        /// 增加历史图像
        /// </summary>
        /// <param name="historyImages">历史图像数组</param>
        /// <returns>返回成功增加的历史图像数目</returns>
        public int AddHistoryImage(Image<Ycc,byte>[] historyImages)
        {
            int added = 0;
            if (historyImages != null && historyImages.Length > 0)
            {
                foreach (Image<Ycc,byte> historyImage in historyImages)
                {
                    if (AddHistoryImage(historyImage))
                        added++;
                }
            }
            return added;
        }

        /// <summary>
        /// 增加历史图像
        /// </summary>
        /// <param name="historyImages">历史图像列表</param>
        /// <returns>返回成功增加的历史图像数目</returns>
        public int AddHistoryImage(List<Image<Ycc,byte>> historyImages)
        {
            return AddHistoryImage(historyImages.ToArray());
        }

        /// <summary>
        /// 增加历史图像
        /// </summary>
        /// <param name="historyImage">历史图像</param>
        /// <returns>是否增加成功</returns>
        public bool AddHistoryImage(Image<Bgr, byte> historyImage)
        {
            Image<Ycc, byte> image = historyImage.Convert<Ycc, byte>();
            bool success = AddHistoryImage(image);
            image.Dispose();
            return success;
        }

        /// <summary>
        /// 增加历史图像
        /// </summary>
        /// <param name="historyImages">历史图像数组</param>
        /// <returns>返回成功增加的历史图像数目</returns>
        public int AddHistoryImage(Image<Bgr, byte>[] historyImages)
        {
            int added = 0;
            if (historyImages != null && historyImages.Length > 0)
            {
                foreach (Image<Bgr, byte> historyImage in historyImages)
                {
                    if (AddHistoryImage(historyImage))
                        added++;
                }
            }
            return added;
        }

        /// <summary>
        /// 增加历史图像
        /// </summary>
        /// <param name="historyImages">历史图像列表</param>
        /// <returns>返回成功增加的历史图像数目</returns>
        public int AddHistoryImage(List<Image<Bgr, byte>> historyImages)
        {
            return AddHistoryImage(historyImages.ToArray());
        }

        /// <summary>
        /// 训练背景模型
        /// </summary>
        /// <returns>返回训练是否成功</returns>
        unsafe public bool TrainBackgroundModel()
        {
            bool success = false;
            if (historyImages.Count >= param.n)
            {
                //0.初始化收敛图像，个数为param.m
                List<Image<Ycc, byte>> convergenceImages = new List<Image<Ycc, byte>>(param.m);
                for (int i = 0; i < param.m; i++)
                    convergenceImages.Add(new Image<Ycc, byte>(width, height));
                //1.将历史图像分为m组，以每组的位置为矩形窗的起点，对通道Y在历史图像中进行MeanShift计算，结果窗的中点为收敛中心，该中心的值为收敛值，将收敛值加入到convergenceImageData中。
                int numberPerGroup = param.n / param.m; //每组图像的数目
                MCvConnectedComp comp;                                  //保存Mean Shift计算结果的连接部件
                int offsetHistoryImage;                                                     //历史图像中某个像素相对图像数据起点的偏移量
                int widthStepHistoryImage = historyImages[0].MIplImage.widthStep;           //历史图像的每行字节数
                byte*[] ptrHistoryImages = new byte*[param.n];                              //历史图像的数据部分起点数组
                byte* ptrSampleImage = (byte*)sampleImage.MIplImage.imageData.ToPointer();  //样本图像的数据部分起点
                int offsetConvergenceImage;                                                 //收敛图像中某个像素相对图像数据起点的偏移量
                int widthStepConvergenceImage = convergenceImages[0].MIplImage.widthStep;   //收敛图像的每行字节数
                byte*[] ptrConvergenceImages = new byte*[param.m];                          //收敛图像的数据部分起点数组
                for (int i = 0; i < param.n; i++)
                    ptrHistoryImages[i] = (byte*)historyImages[i].MIplImage.imageData.ToPointer();
                for (int i = 0; i < param.m; i++)
                    ptrConvergenceImages[i] = (byte*)convergenceImages[i].MIplImage.imageData.ToPointer();
                //遍历图像的每一行
                for (int row = 0; row < height; row++)
                {
                    //遍历图像的每一列
                    for (int col = 0; col < width; col++)
                    {
                        offsetHistoryImage = row * widthStepHistoryImage + col * 3;
                        offsetConvergenceImage = row * widthStepConvergenceImage + col * 3;
                        //用历史图像在该点的Y通道值组成一副用于Mean Shift计算的样本图像
                        for (int sampleIdx = 0; sampleIdx < param.n; sampleIdx++)
                            *(ptrSampleImage + sampleIdx) = *(ptrHistoryImages[sampleIdx] + offsetHistoryImage);
                        //以每组的位置为矩形窗的起点，用MeanShift过程找到局部极值，由局部极值组成的图像是收敛图像
                        for (int representativeIdx = 0; representativeIdx < param.m; representativeIdx++)
                        {
                            Rectangle window = new Rectangle(representativeIdx * numberPerGroup, 0, numberPerGroup, 1);
                            CvInvoke.cvMeanShift(sampleImage.Ptr, window, param.criteria, out comp);
                            int center = comp.rect.Left + comp.rect.Width / 2;      //收敛中心
                            *(ptrConvergenceImages[representativeIdx] + offsetConvergenceImage) = *(ptrHistoryImages[center] + offsetHistoryImage);
                            *(ptrConvergenceImages[representativeIdx] + offsetConvergenceImage + 1) = *(ptrHistoryImages[center] + offsetHistoryImage + 1);
                            *(ptrConvergenceImages[representativeIdx] + offsetConvergenceImage + 2) = *(ptrHistoryImages[center] + offsetHistoryImage + 2);
                        }
                    }
                }
                //2.将近似的收敛点分类，以得到聚集中心
                //（1）得到收敛中心的最小值Cmin；（2）将[0 , Cmin+t]区间中的收敛中心划为一类；（3）计算已分类点的平均值，作为聚集中心的值，并将聚集中心添加到clusterCenters；（4）删除已分类的收敛中心；（5）重复（0）～（4）直到收敛中心全部归类。
                for (int row = 0; row < height; row++)
                {
                    //遍历图像的每一列
                    for (int col = 0; col < width; col++)
                    {
                        offsetConvergenceImage = row * widthStepConvergenceImage + col * 3;
                        //得到该像素的收敛中心列表
                        List<Ycc> convergenceCenters = new List<Ycc>(param.m);
                        for (int convergenceIdx = 0; convergenceIdx < param.m; convergenceIdx++)
                            convergenceCenters.Add(new Ycc(*(ptrConvergenceImages[convergenceIdx] + offsetConvergenceImage), *(ptrConvergenceImages[convergenceIdx] + offsetConvergenceImage + 1), *(ptrConvergenceImages[convergenceIdx] + offsetConvergenceImage + 2)));
                        while (convergenceCenters.Count > 0)
                        {
                            Ycc Cmin = MinYcc(convergenceCenters);
                            double regionHigh = Cmin.Y + param.t;
                            Ycc sum = new Ycc(0d, 0d, 0d);
                            double li = 0d;
                            for (int i = convergenceCenters.Count - 1; i >= 0; i--)
                            {
                                Ycc ci = convergenceCenters[i];
                                if (ci.Y <= regionHigh)
                                {
                                    sum.Y += ci.Y;
                                    sum.Cr += ci.Cr;
                                    sum.Cb += ci.Cb;
                                    li++;
                                    convergenceCenters.RemoveAt(i);
                                }
                            }
                            Ycc avg = new Ycc(sum.Y / li, sum.Cr / li, sum.Cb / li);
                            double wi = li / param.m;
                            ClusterCenter<Ycc> clusterCenter = new ClusterCenter<Ycc>(avg, wi, li, 0d);
                            clusterCenters[row, col].Add(clusterCenter);
                        }
                    }
                }
                //3.得到最可靠背景模型
                GetMrbm();
                //4.释放资源
                for (int i = 0; i < param.m; i++)
                    convergenceImages[i].Dispose();
                convergenceImages.Clear();
                success = true;
            }
            return success;
        }

        /// <summary>
        /// 训练背景模型（没有使用指针运算进行优化，用于演示流程）
        /// </summary>
        /// <returns>返回训练是否成功</returns>
        private bool TrainBackgroundModel2()
        {
            bool success = false;
            if (historyImages.Count >= param.n)
            {
                //0.初始化收敛图像，个数为param.m
                List<Image<Ycc, byte>> convergenceImages = new List<Image<Ycc, byte>>(param.m);
                for (int i = 0; i < param.m; i++)
                    convergenceImages.Add(new Image<Ycc, byte>(width, height));
                //1.将历史图像分为m组，以每组的位置为矩形窗的起点，对通道Y在历史图像中进行MeanShift计算，结果窗的中点为收敛中心，该中心的值为收敛值，将收敛值加入到convergenceImageData中。
                int numberPerGroup = param.n / param.m; //每组图像的数目
                MCvConnectedComp comp;                                  //保存Mean Shift计算结果的连接部件
                //遍历图像的每一行
                for (int row = 0; row < height; row++)
                {
                    //遍历图像的每一列
                    for (int col = 0; col < width; col++)
                    {
                        //用历史图像在该点的Y通道值组成一副用于Mean Shift计算的样本图像
                        for (int sampleIdx = 0; sampleIdx < param.n; sampleIdx++)
                            sampleImage[0, sampleIdx] = new Gray(historyImages[sampleIdx][row, col].Y);  //这里可以用指针优化访问像素的速度
                        //以每组的位置为矩形窗的起点，用MeanShift过程找到局部极值，由局部极值组成的图像是收敛图像
                        for (int representativeIdx = 0; representativeIdx < param.m; representativeIdx++)
                        {
                            Rectangle window = new Rectangle(representativeIdx * numberPerGroup, 0, numberPerGroup, 1);
                            CvInvoke.cvMeanShift(sampleImage.Ptr, window, param.criteria, out comp);
                            int center = comp.rect.Left + comp.rect.Width / 2;      //收敛中心
                            Ycc ci = historyImages[center][row, col];               //收敛中心对应的像素值
                            convergenceImages[representativeIdx][row, col] = ci;    //将收敛中心添加到收敛图像数据中去（这两句可以用指针优化访问像素的速度）
                        }
                    }
                }
                //2.将近似的收敛点分类，以得到聚集中心
                //（1）得到收敛中心的最小值Cmin；（2）将[0 , Cmin+t]区间中的收敛中心划为一类；（3）计算已分类点的平均值，作为聚集中心的值，并将聚集中心添加到clusterCenters；（4）删除已分类的收敛中心；（5）重复（0）～（4）直到收敛中心全部归类。
                for (int row = 0; row < height; row++)
                {
                    //遍历图像的每一列
                    for (int col = 0; col < width; col++)
                    {
                        //得到该像素的收敛中心列表
                        List<Ycc> convergenceCenters = new List<Ycc>(param.m);
                        for (int convergenceIdx = 0; convergenceIdx < param.m; convergenceIdx++)
                            convergenceCenters.Add(convergenceImages[convergenceIdx][row, col]);
                        while (convergenceCenters.Count > 0)
                        {
                            Ycc Cmin = MinYcc(convergenceCenters);
                            double regionHigh = Cmin.Y + param.t;
                            Ycc sum = new Ycc(0d, 0d, 0d);
                            double li = 0d;
                            for (int i = convergenceCenters.Count - 1; i >= 0; i--)
                            {
                                Ycc ci = convergenceCenters[i];
                                if (ci.Y <= regionHigh)
                                {
                                    sum.Y += ci.Y;
                                    sum.Cr += ci.Cr;
                                    sum.Cb += ci.Cb;
                                    li++;
                                    convergenceCenters.RemoveAt(i);
                                }
                            }
                            Ycc avg = new Ycc(sum.Y / li, sum.Cr / li, sum.Cb / li);
                            double wi = li / param.m;
                            ClusterCenter<Ycc> clusterCenter = new ClusterCenter<Ycc>(avg, wi, li, 0d);
                            clusterCenters[row, col].Add(clusterCenter);
                        }
                    }
                }
                //3.得到最可靠背景模型
                GetMrbm();
                //4.释放资源
                for (int i = 0; i < param.m; i++)
                    convergenceImages[i].Dispose();
                convergenceImages.Clear();
                success = true;
            }
            return success;
        }

        /// <summary>
        /// 训练背景模型
        /// </summary>
        /// <param name="historyImages">历史图像数组</param>
        /// <returns>返回训练是否成功</returns>
        public bool TrainBackgroundModel(Image<Ycc,byte>[] historyImages)
        {
            AddHistoryImage(historyImages);
            return TrainBackgroundModel();
        }

        /// <summary>
        /// 训练背景模型
        /// </summary>
        /// <param name="historyImages">历史图像数组</param>
        /// <returns>返回训练是否成功</returns>
        public bool TrainBackgroundModel(List<Image<Ycc,byte>> historyImages)
        {
            AddHistoryImage(historyImages);
            return TrainBackgroundModel();
        }

        /// <summary>
        /// 训练背景模型
        /// </summary>
        /// <param name="historyImages">历史图像数组</param>
        /// <returns>返回训练是否成功</returns>
        public bool TrainBackgroundModel(Image<Bgr, byte>[] historyImages)
        {
            AddHistoryImage(historyImages);
            return TrainBackgroundModel();
        }

        /// <summary>
        /// 训练背景模型
        /// </summary>
        /// <param name="historyImages">历史图像数组</param>
        /// <returns>返回训练是否成功</returns>
        public bool TrainBackgroundModel(List<Image<Bgr, byte>> historyImages)
        {
            AddHistoryImage(historyImages);
            return TrainBackgroundModel();
        }

        /// <summary>
        /// 得到Ycc列表中的最小值（仅比较Y分量）
        /// </summary>
        /// <param name="yccList"></param>
        /// <returns></returns>
        private Ycc MinYcc(List<Ycc> yccList)
        {
            Ycc min = yccList[0];
            foreach (Ycc ycc in yccList)
            {
                if (ycc.Y < min.Y)
                    min = ycc;
            }
            return min;
        }

        /// <summary>
        /// 得到聚集中心列表中的最大值（比较wi）
        /// </summary>
        /// <param name="clusterCenters"></param>
        /// <returns></returns>
        private ClusterCenter<Ycc> MaxClusterCenter(List<ClusterCenter<Ycc>> clusterCenters)
        {
            ClusterCenter<Ycc> max = clusterCenters[0];
            foreach (ClusterCenter<Ycc> center in clusterCenters)
            {
                if (center.wi > max.wi)
                    max = center;
            }
            return max;
        }

        /// <summary>
        /// 得到最可靠背景模型MRBM：在聚集中心选择wi最大的值（没有使用指针运算进行优化，用于演示流程）
        /// </summary>
        private void GetMrbm2()
        {
            //遍历图像的每一行
            for (int row = 0; row < height; row++)
            {
                //遍历图像的每一列
                for (int col = 0; col < width; col++)
                    mrbm[row, col] = MaxClusterCenter(clusterCenters[row, col]).ci;
            }
        }

        /// <summary>
        /// 得到最可靠背景模型MRBM：在聚集中心选择wi最大的值
        /// </summary>
        unsafe private void GetMrbm()
        {
            int widthStepMrbm = mrbm.MIplImage.widthStep;
            byte* ptrMrbm = (byte*)mrbm.MIplImage.imageData.ToPointer();
            byte* ptrPixel;
            Ycc ci;
            //遍历图像的每一行
            for (int row = 0; row < height; row++)
            {
                //遍历图像的每一列
                for (int col = 0; col < width; col++)
                {
                    ci = MaxClusterCenter(clusterCenters[row, col]).ci;
                    ptrPixel = ptrMrbm + row * widthStepMrbm + col * 3;
                    *ptrPixel = (byte)ci.Y;
                    *(ptrPixel + 1) = (byte)ci.Cr;
                    *(ptrPixel + 2) = (byte)ci.Cb;
                }
            }
        }

        /// <summary>
        /// 更新背景模型，同时计算相应的前景和背景（没有使用指针运算进行优化，用于演示流程）
        /// </summary>
        /// <param name="currentFrame">当前帧图像</param>
        private void Update2(Image<Ycc, byte> currentFrame)
        {
            //1.将当前帧加入到历史图像的末尾
            AddHistoryImage(currentFrame);
            frameCount++;
            //2.将背景掩码图像整个设置为白色，在检测时再将前景像素置零
            backgroundMask.SetValue(255d);
            //3.遍历图像的每个像素，确定前景或背景；同时进行背景维持操作。
            int numberPerGroup = param.n / param.m;
            int lastIdx = param.n - 1;
            //遍历图像的每一行
            for (int row = 0; row < height; row++)
            {
                //遍历图像的每一列
                for (int col = 0; col < width; col++)
                {
                    int nearestIndex;   //最近的聚集中心索引
                    double d = GetMinD(historyImages[lastIdx][row, col].Y, clusterCenters[row, col], out nearestIndex);    //得到最小差值d
                    if (d > param.t)
                    {
                        //该点为前景：以该点附近的矩形窗{n-numberPerGroup,0,numberPerGroup,1}开始进行MeanShift运算，并得到新的收敛中心Cnew（wi=1/m），将Cnew加入到聚集中心clusterCenters
                        //用历史图像在该点的Y通道值组成一副用于Mean Shift计算的样本图像
                        for (int sampleIdx = 0; sampleIdx < param.n; sampleIdx++)
                            sampleImage[0, sampleIdx] = new Gray(historyImages[sampleIdx][row, col].Y);     //这里可以用指针运算来提高速度
                        Rectangle window = new Rectangle(param.n - numberPerGroup, 0, numberPerGroup, 1);
                        MCvConnectedComp comp;
                        CvInvoke.cvMeanShift(sampleImage.Ptr, window, param.criteria, out comp);
                        int center = comp.rect.Left + comp.rect.Width / 2;      //收敛中心
                        ClusterCenter<Ycc> cnew = new ClusterCenter<Ycc>(historyImages[center][row, col], 1d / (param.m + frameCount), 1d, frameCount);  //将收敛中心作为新的聚集中心
                        clusterCenters[row, col].Add(cnew);
                        //设置背景掩码图像的前景点
                        backgroundMask[row, col] = new Gray(0d);
                    }
                    else
                    {
                        //该点为背景：更新最近聚集中心的ci为(li+1)/m
                        clusterCenters[row, col][nearestIndex].li++;
                        clusterCenters[row, col][nearestIndex].wi = clusterCenters[row, col][nearestIndex].li / (param.m + frameCount);
                        clusterCenters[row, col][nearestIndex].updateFrameNo = frameCount;
                    }
                }
            }
            //4.生成最可靠背景模型
            GetMrbm();
        }

        /// <summary>
        /// 更新背景模型，同时计算相应的前景和背景
        /// </summary>
        /// <param name="currentFrame">当前帧图像</param>
        private void Update2(Image<Bgr, byte> currentFrame)
        {
            Image<Ycc, byte> image = currentFrame.Convert<Ycc, byte>();
            Update(image);
            image.Dispose();
        }

        /// <summary>
        /// 更新背景模型，同时计算相应的前景和背景
        /// </summary>
        /// <param name="currentFrame">当前帧图像</param>
        unsafe public void Update(Image<Ycc, byte> currentFrame)
        {
            //1.将当前帧加入到历史图像的末尾
            AddHistoryImage(currentFrame);
            frameCount++;
            //2.将背景掩码图像整个设置为白色，在检测时再将前景像素置零
            backgroundMask.SetValue(255d);
            //3.遍历图像的每个像素，确定前景或背景；同时进行背景维持操作。
            int numberPerGroup = param.n / param.m;
            int lastIdx = param.n - 1;
            int offsetHistoryImage;                                                     //历史图像中某个像素相对图像数据起点的偏移量
            int widthStepHistoryImage = historyImages[0].MIplImage.widthStep;           //历史图像的每行字节数
            byte*[] ptrHistoryImages = new byte*[param.n];                              //历史图像的数据部分起点数组
            byte* ptrSampleImage = (byte*)sampleImage.MIplImage.imageData.ToPointer();  //样本图像的数据部分起点
            int widthStepBackgroundMask = backgroundMask.MIplImage.widthStep;           //背景掩码图像的每行字节数
            byte* ptrBackgroundMask = (byte*)backgroundMask.MIplImage.imageData.ToPointer();  //背景掩码图像的数据部分起点
            byte f = 0;                                                                 //前景对应的颜色值
            for (int i = 0; i < param.n; i++)
                ptrHistoryImages[i] = (byte*)historyImages[i].MIplImage.imageData.ToPointer();
            //遍历图像的每一行
            for (int row = 0; row < height; row++)
            {
                //遍历图像的每一列
                for (int col = 0; col < width; col++)
                {
                    offsetHistoryImage = row * widthStepHistoryImage + col * 3;
                    int nearestIndex;   //最近的聚集中心索引
                    double d = GetMinD((double)(*(ptrHistoryImages[lastIdx] + offsetHistoryImage)), clusterCenters[row, col], out nearestIndex);    //得到最小差值d
                    if (d > param.t)
                    {
                        //该点为前景：以该点附近的矩形窗{n-numberPerGroup,0,numberPerGroup,1}开始进行MeanShift运算，并得到新的收敛中心Cnew（wi=1/m），将Cnew加入到聚集中心clusterCenters
                        //用历史图像在该点的Y通道值组成一副用于Mean Shift计算的样本图像
                        for (int sampleIdx = 0; sampleIdx < param.n; sampleIdx++)
                            *(ptrSampleImage + sampleIdx) = *(ptrHistoryImages[sampleIdx] + offsetHistoryImage);
                        Rectangle window = new Rectangle(param.n - numberPerGroup, 0, numberPerGroup, 1);
                        MCvConnectedComp comp;
                        CvInvoke.cvMeanShift(sampleImage.Ptr, window, param.criteria, out comp);
                        int center = comp.rect.Left + comp.rect.Width / 2;      //收敛中心
                        ClusterCenter<Ycc> cnew = new ClusterCenter<Ycc>(historyImages[center][row, col], 1d / (param.m + frameCount), 1d, frameCount);  //将收敛中心作为新的聚集中心
                        clusterCenters[row, col].Add(cnew);
                        //设置背景掩码图像的前景点
                        *(ptrBackgroundMask + row * widthStepBackgroundMask + col) = f;
                    }
                    else
                    {
                        //该点为背景：更新最近聚集中心的ci为(li+1)/m
                        clusterCenters[row, col][nearestIndex].li++;
                        clusterCenters[row, col][nearestIndex].wi = clusterCenters[row, col][nearestIndex].li / (param.m + frameCount);
                        clusterCenters[row, col][nearestIndex].updateFrameNo = frameCount;
                    }
                }
            }
            //4.生成最可靠背景模型
            GetMrbm();
        }

        public void Update(Image<Bgr, byte> currentFrame)
        {
            Image<Ycc, byte> image = currentFrame.Convert<Ycc, byte>();
            Update(image);
            image.Dispose();
        }

        /// <summary>
        /// 用wi>=theta作为条件选择可能的背景模型Cb；对每个观测值x0，计算x0与Cb的最小差值d
        /// </summary>
        /// <param name="x0">观测值x0</param>
        /// <param name="centerList">某像素对应的聚集中心列表</param>
        /// <param name="nearestIndex">输出参数：最近的聚集中心索引</param>
        /// <returns>返回最小差值d</returns>
        private double GetMinD(double x0, List<ClusterCenter<Ycc>> centerList, out int nearestIndex)
        {
            double d = double.MaxValue;
            nearestIndex = 0;
            for (int idx = 0; idx < centerList.Count; idx++)
            {
                ClusterCenter<Ycc> center = centerList[idx];
                if (center.wi >= param.theta)
                {
                    double d0 = Math.Abs(center.ci.Y - x0);
                    if (d0 < d)
                    {
                        d = d0;
                        nearestIndex = idx;
                    }
                }
            }
            return d;
        }

        /// <summary>
        /// 清除不活跃的聚集中心
        /// </summary>
        /// <param name="staleThresh">不活跃阀值，不活跃帧数大于该值的聚集中心将被清除</param>
        public void ClearStale(int staleThresh)
        {
            //遍历每个像素的聚集中心
            for (int row = 0; row < height; row++)
            {
                for (int col = 0; col < width; col++)
                {
                    for (int idx = clusterCenters[row, col].Count - 1; idx >= 0; idx--)
                    {
                        if (frameCount - clusterCenters[row, col][idx].updateFrameNo > staleThresh)
                            clusterCenters[row, col].RemoveAt(idx);
                    }
                }
            }
        }

    }

    /// <summary>
    /// 聚集中心
    /// </summary>
    /// <typeparam name="TColor">聚集中心使用的色彩空间</typeparam>
    public class ClusterCenter<TColor>
        where TColor : struct, IColor
    {
        public TColor ci;              //聚集中心的像素值
        public double wi;              //聚集中心的权重
        public double li;              //聚集中心包含的收敛点数目
        public double updateFrameNo;   //更新该聚集中心时的帧数：用于消除消极的聚集中心

        public ClusterCenter(TColor ci, double wi, double li, double updateFrameNo)
        {
            this.ci = ci;
            this.li = li;
            this.wi = wi;
            this.updateFrameNo = updateFrameNo;
        }
    }

    /// <summary>
    /// 非参数背景模型的参数
    /// </summary>
    public struct NBGParameter
    {
        public int n;                       //样本数目：需要被保留的历史图像数目
        public int m;                       //典型点数目：历史图像需要被分为多少组
        public double theta;                //权重系数：权重大于该值的聚集中心为候选背景
        public double t;                    //最小差值：观测值与候选背景的最小差值大于该值时，为前景；否则为背景
        public MCvTermCriteria criteria;    //Mean Shift计算的终止条件：包括最大迭代次数和终止计算的精度

        public NBGParameter(int n, int m, double theta, double t, MCvTermCriteria criteria)
        {
            this.n = n;
            this.m = m;
            this.theta = theta;
            this.t = t;
            this.criteria.type = criteria.type;
            this.criteria.max_iter = criteria.max_iter;
            this.criteria.epsilon = criteria.epsilon;
        }

        public static NBGParameter GetDefaultNBGParameter()
        {
            return new NBGParameter(100, 10, 0.3d, 10d, new MCvTermCriteria(100, 1d));
        }
    }
}

3 NBGModel类介绍
3.1 属性
Width——获取图像的宽度
Height——获取图像的高度
Param——获取参数设置
Mrbm——获取最可靠背景模型图像
BackgroundMask——获取背景掩码图像
ForegroundMask——获取前景掩码图像
FrameCount——获取已被检测的帧数

3.2 构造函数
public NBGModel(int width, int height)——用默认的参数初始化NBGModel，等价于NBGModel(width, height, NBGParameter.GetDefaultNBGParameter())
public NBGModel(int width, int height, NBGParameter param)——用指定的参数初始化NBGModel

3.3 方法
AddHistoryImage——添加一幅或者一组历史图像
TrainBackgroundModel——训练背景模型；如果传入了历史图像，则先添加历史图像，然后再训练背景模型
Update——更新背景模型，同时检测前景
ClearStale——清除消极的聚集中心
Dispose——释放资源

4 体会
NBGModel的确非常有效，非常简洁，特别适用于伴随复杂运动对象的背景建模。我特意选取了PETS2009中的素材对其做了一些测试，结果也证明了NBGModel的优越性。不过需要指出的是，它需要占用大量的内存（主要因为需要保存n幅历史图像）；它的计算量比较大。
在使用的过程中，它始终需要在内存中缓存n幅历史图像，1幅最可靠背景模型图像，1幅背景掩码图像，近似m幅图像（聚集中心）；而在训练阶段，更需要临时存储m幅收敛图像。
例如：样本数目为100，典型点数目为10，图像尺寸为768x576时，所用的内存接近300M，训练背景需要大约需要33秒，而对每幅图像进行前景检测大约需要600ms。虽然可以使用并行编程来提高性能，但是并不能从根本上解决问题。
（注：测试电脑的CPU为AMD闪龙3200+，内存1.5G。）
看来，有必要研究一种新的方法，目标是检测效果更好，内存占用低，处理更快速。目前的想法是使用《Wallflower: Principles and Practice of Background Manitenance》中的3层架构（时间轴上的像素级处理，像素间的区域处理，帧间处理），但是对每层架构都选用目前流行的处理方式，并对处理方式进行优化。时间轴上的像素级处理打算使用CodeBook方法，但是增加本文的一些思想。像素间的区域处理打算参考《基于区域相关的核函数背景建模算法》中的方法。帧间处理预计会采用全局灰度统计值作为依据。

最后，按照惯例：感谢您耐心看完本文，希望对您有所帮助。
本文所述方法及代码仅用于学习研究，不得用于商业目的。

本文链接