运动背景分割法Background Segment主要是指通过不同方法拟合模型建立背景图像，将当前帧与背景图像进行相减比较获得运动区域。下图所示为检测图像：

通过前面的检测帧建立背景模型，获得背景图像。然后检测图像与背景图像相减即为运动图像，黑色区域为背景，白色区域为运动目标，如下图所示：

在OpenCV标注库中有两种背景分割器：KNN，MOG2。但是实际上OpenCV_contrib库的bgsegm模块中还有其他几种背景分割器。本文主要介绍OpenCV_contrib中的运动背景分割模型及其用法，并对不同检测模型的性能和效果进行对比。

文章目录

  • ​​1 方法介绍​​
  • ​​2 代码与方法评估​​
  • ​​2.1 代码​​
  • ​​2.2 评价​​
  • ​​2.3 方法选择​​
  • ​​3 参考​​

1 方法介绍

OpenCV_contrib中bgsegm模块主要有GMG, CNT, KNN, MOG, MOG2, GSOC, LSBP等7种背景分割器，其中KNN,MOG2可以在OpenCV标准库中直接使用，其他需要在OpenCV_contrib库中使用。具体各个方法介绍如下：

  • GMG：基于像素颜色进行背景建模
  • CNT：基于像素点计数进行背景建模
  • KNN：基于K最近邻进行背景建模
  • MOG：基于混合高斯进行背景建模
  • MOG2：基于混合高斯进行背景建模，MOG的升级版本
  • GSOC：类似LSBP
  • LSBP：基于LBP进行背景建模

各个方法提出时间、相关论文和OpenCV函数接口介绍如下表所示：

方法

提出时间

OpenCV函数接口介绍

GMG

​​2012​​

​​BackgroundSubtractorGMG​​

CNT

​​2016​​

​​BackgroundSubtractorCNT​​

KNN

​​2006​​

​​BackgroundSubtractorKNN​​

MOG

​​2001​​

​​BackgroundSubtractorMOG​​

MOG2

​​2004​​

​​BackgroundSubtractorMOG2​​

GSOC

2016

​​BackgroundSubtractorGSOC​​

LSBP

​​2016​​

​​BackgroundSubtractorLSBP​​

OpenCV contrib库的编译安装见：

​​OpenCV_contrib库在windows下编译使用指南​​

2 代码与方法评估

2.1 代码

下述代码介绍了OpenCV_contrib的bgsegm模块中不同背景分割方法C++和Python的调用。对比了不同背景分割方法在示例视频下，单线程和多线程的效果。

代码和示例视频下载地址：

​​https://github.com/luohenyueji/OpenCV-Practical-Exercise​​

完整代码如下：

C++

#include <opencv2/opencv.hpp>
#include <opencv2/bgsegm.hpp>
#include <iostream>

using namespace cv;
using namespace cv::bgsegm;

const String algos[7] = { "GMG", "CNT", "KNN", "MOG", "MOG2", "GSOC", "LSBP" };

// 创建不同的背景分割识别器
static Ptr<BackgroundSubtractor> createBGSubtractorByName(const String& algoName)
{
  Ptr<BackgroundSubtractor> algo;
  if (algoName == String("GMG"))
    algo = createBackgroundSubtractorGMG(20, 0.7);
  else if (algoName == String("CNT"))
    algo = createBackgroundSubtractorCNT();
  else if (algoName == String("KNN"))
    algo = createBackgroundSubtractorKNN();
  else if (algoName == String("MOG"))
    algo = createBackgroundSubtractorMOG();
  else if (algoName == String("MOG2"))
    algo = createBackgroundSubtractorMOG2();
  else if (algoName == String("GSOC"))
    algo = createBackgroundSubtractorGSOC();
  else if (algoName == String("LSBP"))
    algo = createBackgroundSubtractorLSBP();

  return algo;
}

int main()
{
  // 视频路径
  String videoPath = "./video/vtest.avi";

  // 背景分割识别器序号
  int algo_index = 0;
  // 创建背景分割识别器
  Ptr<BackgroundSubtractor> bgfs = createBGSubtractorByName(algos[algo_index]);

  // 打开视频
  VideoCapture cap;
  cap.open(videoPath);

  // 如果视频没有打开
  if (!cap.isOpened())
  {
    std::cerr << "Cannot read video. Try moving video file to sample directory." << std::endl;
    return -1;
  }

  // 输入图像
  Mat frame;
  // 运动前景
  Mat fgmask;
  // 最后显示的图像
  Mat segm;

  // 延迟等待时间
  int delay = 30;
  // 获得运行环境CPU的核心数
  int nthreads = getNumberOfCPUs();
  // 设置线程数
  setNumThreads(nthreads);

  // 是否显示运动前景
  bool show_fgmask = false;

  // 平均执行时间
  float average_Time = 0.0;
  // 当前帧数
  int frame_num = 0;
  // 总执行时间
  float sum_Time = 0.0;

  for (;;)
  {
    // 提取帧
    cap >> frame;

    // 如果图片为空
    if (frame.empty())
    {
      // CAP_PROP_POS_FRAMES表示当前帧
      // 本句话表示将当前帧设定为第0帧
      cap.set(CAP_PROP_POS_FRAMES, 0);
      cap >> frame;
    }

    double time0 = static_cast<double>(getTickCount());

    // 背景建模
    bgfs->apply(frame, fgmask);
    time0 = ((double)getTickCount() - time0) / getTickFrequency();
    // 总执行时间
    sum_Time += time0;
    // 平均每帧执行时间
    average_Time = sum_Time / (frame_num + 1);

    if (show_fgmask)
    {
      segm = fgmask;
    }
    else
    {
      // 根据segm = alpha * frame + beta改变图片
      // 参数分别为，输出图像，输出图像格式，alpha值，beta值
      frame.convertTo(segm, CV_8U, 0.5);
      // 图像叠加
      // 参数分别为，输入图像/颜色1，输入图像/颜色2，输出图像，掩膜
      // 掩膜表示叠加范围
      add(frame, Scalar(100, 100, 0), segm, fgmask);
    }

    // 显示当前方法
    cv::putText(segm, algos[algo_index], Point(10, 30), FONT_HERSHEY_PLAIN, 2.0, Scalar(255, 0, 255), 2, LINE_AA);
    // 显示当前线程数
    cv::putText(segm, format("%d threads", nthreads), Point(10, 60), FONT_HERSHEY_PLAIN, 2.0, Scalar(255, 0, 255), 2, LINE_AA);
    // 显示当前每帧执行时间
    cv::putText(segm, format("averageTime %f s", average_Time), Point(10, 90), FONT_HERSHEY_PLAIN, 2.0, Scalar(255, 0, 255), 2, LINE_AA);

    cv::imshow("FG Segmentation", segm);

    int c = waitKey(delay);

    // 修改等待时间
    if (c == ' ')
    {
      delay = delay == 30 ? 1 : 30;
    }

    // 按C背景分割识别器
    if (c == 'c' || c == 'C')
    {
      algo_index++;
      if (algo_index > 6)
        algo_index = 0;

      bgfs = createBGSubtractorByName(algos[algo_index]);
    }

    // 设置线程数
    if (c == 'n' || c == 'N')
    {
      nthreads++;
      if (nthreads > 8)
        nthreads = 1;

      setNumThreads(nthreads);
    }

    // 是否显示背景
    if (c == 'm' || c == 'M')
    {
      show_fgmask = !show_fgmask;
    }

    // 退出
    if (c == 'q' || c == 'Q' || c == 27)
    {
      break;
    }

    // 当前帧数增加
    frame_num++;
    if (100 == frame_num)
    {
      String strSave = "out_" + algos[algo_index] + ".jpg";
      imwrite(strSave, segm);
    }
  }

  return 0;
}

Python

# -*- coding: utf-8 -*-
"""
Created on Wed Aug 12 19:20:56 2020

@author: luohenyueji
"""

import cv2
from time import *

# TODO 背景减除算法集合
ALGORITHMS_TO_EVALUATE = [
    (cv2.bgsegm.createBackgroundSubtractorGMG(20, 0.7), 'GMG'),
    (cv2.bgsegm.createBackgroundSubtractorCNT(), 'CNT'),
    (cv2.createBackgroundSubtractorKNN(), 'KNN'),
    (cv2.bgsegm.createBackgroundSubtractorMOG(), 'MOG'),
    (cv2.createBackgroundSubtractorMOG2(), 'MOG2'),
    (cv2.bgsegm.createBackgroundSubtractorGSOC(), 'GSOC'),
    (cv2.bgsegm.createBackgroundSubtractorLSBP(), 'LSBP'),
]


# TODO 主函数
def main():
    # 背景分割识别器序号
    algo_index = 0
    subtractor = ALGORITHMS_TO_EVALUATE[algo_index][0]
    videoPath = "./video/vtest.avi"
    show_fgmask = False

    # 获得运行环境CPU的核心数
    nthreads = cv2.getNumberOfCPUs()
    # 设置线程数
    cv2.setNumThreads(nthreads)

    # 读取视频
    capture = cv2.VideoCapture(videoPath)

    # 当前帧数
    frame_num = 0
    # 总执行时间
    sum_Time = 0.0

    while True:
        ret, frame = capture.read()
        if not ret:
            return
        begin_time = time()
        fgmask = subtractor.apply(frame)
        end_time = time()
        run_time = end_time - begin_time
        sum_Time = sum_Time + run_time
        # 平均执行时间
        average_Time = sum_Time / (frame_num + 1)

        if show_fgmask:
            segm = fgmask
        else:
            segm = (frame * 0.5).astype('uint8')
            cv2.add(frame, (100, 100, 0, 0), segm, fgmask)

        # 显示当前方法
        cv2.putText(segm, ALGORITHMS_TO_EVALUATE[algo_index][1], (10, 30), cv2.FONT_HERSHEY_PLAIN, 2.0, (255, 0, 255),
                    2,
                    cv2.LINE_AA)
        # 显示当前线程数
        cv2.putText(segm, str(nthreads) + " threads", (10, 60), cv2.FONT_HERSHEY_PLAIN, 2.0, (255, 0, 255), 2,
                    cv2.LINE_AA)
        # 显示当前每帧执行时间
        cv2.putText(segm, "averageTime {} s".format(average_Time), (10, 90), cv2.FONT_HERSHEY_PLAIN, 2.0,
                    (255, 0, 255), 2, cv2.LINE_AA);

        cv2.imshow('some', segm)
        key = cv2.waitKey(1) & 0xFF
        frame_num = frame_num + 1

        # 按'q'健退出循环
        if key == ord('q'):
            break

    cv2.destroyAllWindows()


if __name__ == '__main__':
    main()

2.2 评价

在i5六代CPU(太渣就不具体介绍)，12G内存，VS2017 C++ Release平台下，各种方法处理速度如下表所示。

方法

单线程单帧处理平均时间/ms

四线程单帧处理平均时间/ms

GMG

38.6

31.3

CNT

4.6

2.9

KNN

19.8

9.3

MOG

16.3

15.6

MOG2

15.3

7.7

GSOC

66.3

49.4

LSBP

193.8

94.9

各个方法，个人评价如下：

  • GMG 初始建模帧会快速变化，导致全屏运动，对邻近运动目标检测效果一般，GMG需要自行设定参数（所以新的OpenCV标准库移除了GMG）总体效果一般。效果如图所示：
  • CNT 初始建模帧在一段时间持续变化导致全屏运动，运动目标过快可能会出现鬼影，低端设备速度很快，高端硬件速度和MOG2相近，总体效果不错。效果如图所示：
  • KNN 初始建模在一段时间持续变化导致全屏运动，运动目标都能较好检测出来，速度也还不错，总体效果不错。效果如图所示：
  • MOG 建模会丢失运动目标，速度不错，总体效果不错。效果如图所示：
  • MOG2 运动区域过大，容易出现细微变化区域，总体效果最好，MOG的升级版本，运动区域基本能检测出来，不过需要自行设定参数。效果如图所示：
  • GSOC 建模时间过短出现鬼影，随着建模时间越来越长，检测效果会变好，会逐渐消除鬼影，LSBP的升级版本，相对还行。效果如图所示：
  • LSBP 极易出现鬼影，建模次数越多，建模消耗时间有所减少，但是鬼影会偶尔出现。效果如图所示：

2.3 方法选择

  • 追求速度 CNT or MOG2 or KNN
    如果是低端设备或者并行任务多毫无疑问是CNT最好,高端设备还是MOG2更好，毕竟MOG2检测效果优于CNT，KNN也是不错的选择。

  • 追求质量 MOG2 or KNN or GSOC
    检测质量MOG2和KNN差不多，GSOC建模时间长会很不错，但是GSOC太慢了。如果不在意速度GSOC很好，其他还是MOG2和KNN。

  • 平衡质量和速度 MOG2 or KNN
    质量和速度均衡MOG2和KNN最不错，不然为什么MOG2和KNN放在标准库，其他在contrib库。MOG2需要调整参数，不过速度和质量优于KNN。如果图省心，不想调整参数，选KNN最好。

总的来说实际应用中，MOG2用的最多，KNN其次，CNT一般用于树莓派和多检测任务中。

3 参考