BackgroundSubtractorMOG部分代码

1、Opencv的帮助文档地址：http://docs.opencv.org/2.4/modules/video/doc/motion_analysis_and_object_tracking.html?highlight=backgroundsubtractormog#backgroundsubtractormog

2、关键函数

2.1、BackgroundSubtractorMOG::BackgroundSubtractorMOG(int _history, int _nmixtures,

double _backgroundRatio,

double _noiseSigma)

2.2、void BackgroundSubtractorMOG::operator()(InputArray _image, OutputArray _fgmask, double learningRate)

3、几点说明：

3.1、这个参数int _history 的用途。仅仅用于第一帧学习率，或者在学习率为负值时的学习率计算，其他地方没有使用

learningRate = learningRate >= 0 && nframes > 1 ? learningRate : 1./min( nframes, history );

3.2、 _backgroundRatio的用途，是个阈值，用于判断前多少个model作为背景模型。是前n个模型权重的和的比较阈值。具体可以参考下面代码注释部分

**代码摘自opencv

//backgroundRatio : 通过代码可知，就是k个模型的权重累加值>= backgroundRatio ，此时前k个model就是背景的model，大于k的model就是前景的model
//nmixtures : model数量
static void process8uC1( const Mat& image, Mat& fgmask, double learningRate,
Mat& bgmodel, int nmixtures, double backgroundRatio,
double varThreshold, double noiseSigma )
{
int x, y, k, k1, rows = image.rows, cols = image.cols;
float alpha = (float)learningRate, T = (float)backgroundRatio, vT = (float)varThreshold;
int K = nmixtures;
MixData<float>* mptr = (MixData<float>*)bgmodel.data;

const float w0 = (float)defaultInitialWeight;
const float sk0 = (float)(w0/(defaultNoiseSigma*2));
const float var0 = (float)(defaultNoiseSigma*defaultNoiseSigma*4);
const float minVar = (float)(noiseSigma*noiseSigma);

for( y = 0; y < rows; y++ )
{
const uchar* src = image.ptr<uchar>(y);
uchar* dst = fgmask.ptr<uchar>(y);

if( alpha > 0 )
{
// 考虑更新模型的情况。
for( x = 0; x < cols; x++, mptr += K )
{
float wsum = 0;
float pix = src[x];
int kHit = -1, kForeground = -1;

// K：是高斯分布数量
for( k = 0; k < K; k++ )
{
float w = mptr[k].weight;
wsum += w;
if( w < FLT_EPSILON ) // 由于mptr是按权重降序排列的，因此权重太小的情况就结束循环
break;
float mu = mptr[k].mean;
float var = mptr[k].var;
float diff = pix - mu;
float d2 = diff*diff;
if( d2 < vT*var ) //同样判断是否是匹配的分布
{
wsum -= w; // 这里得到的wsum是前面k-1个不匹配的分布的权重的累加和
float dw = alpha*(1.f - w); //
mptr[k].weight = w + dw; //更新权重
mptr[k].mean = mu + alpha*diff; // 更新均值
var = max(var + alpha*(d2 - var), minVar); // 更新方差
mptr[k].var = var;
mptr[k].sortKey = w/sqrt(var); // 排序的关键字，为什么？

for( k1 = k-1; k1 >= 0; k1-- ) // 重新排序，通过交换的方式，将该高斯分布适当前移
{
if( mptr[k1].sortKey >= mptr[k1+1].sortKey )
break;
std::swap( mptr[k1], mptr[k1+1] );
}

kHit = k1+1;
break;
}
}

if( kHit < 0 ) // no appropriate gaussian mixture found at all, remove the weakest mixture and create a new one
{
kHit = k = min(k, K-1);
wsum += w0 - mptr[k].weight;
mptr[k].weight = w0;
mptr[k].mean = pix;
mptr[k].var = var0;
mptr[k].sortKey = sk0;
}
else
for( ; k < K; k++ )
wsum += mptr[k].weight;

float wscale = 1.f/wsum;
wsum = 0;
for( k = 0; k < K; k++ )
{
wsum += mptr[k].weight *= wscale;
mptr[k].sortKey *= wscale; // 前面权重或者分布有变化，这里做更新
if( wsum > T && kForeground < 0 )
kForeground = k+1;
}

dst[x] = (uchar)(-(kHit >= kForeground));
}
}
else
{
//不考虑更新模型的情况。这里更好理解些，看完这个在看考虑学习率的场景
for( x = 0; x < cols; x++, mptr += K )
{
float pix = src[x];
int kHit = -1, kForeground = -1;
//kForeground：前多少个分布是背景的分布。大于kForeground的就是前景分布
//kHit: 表示给定的像素最符合哪个分布 ；
//kHit <0 ,表示没有匹配的分布，自然是前景；
//kHit<kForeground 自然是背景；否则是前景

//这里判断给定的像素值与哪个高斯分布最匹配，匹配的依据就是小于vT倍的方差
for( k = 0; k < K; k++ )
{
if( mptr[k].weight < FLT_EPSILON )
break;
float mu = mptr[k].mean;
float var = mptr[k].var;
float diff = pix - mu;
float d2 = diff*diff;
if( d2 < vT*var )
{
kHit = k;
break;
}
}

if( kHit >= 0 ) //若是没有找到匹配的分布，就被判定为为前景，不需要下面的计算
{
float wsum = 0;
for( k = 0; k < K; k++ )
{
wsum += mptr[k].weight;
if( wsum > T )
{
kForeground = k+1; // 前k个作为背景模型，这里计算的到k值。
break;
}
}
}

dst[x] = (uchar)(kHit < 0 || kHit >= kForeground ? 255 : 0);// kForeground表示前kForeground个作为背景模型，若是kHit>=kForeground说明匹配的高斯分布已经不在前kForeground中，因此该像素点就是前景了。否则就判定为背景点
}
}
}
}

[1]: 《An Improved Adaptive Background Mixture Model for Realtime Tracking with Shadow Detection》