备案控制台
探索云世界
开发者社区 人工智能 文章 正文

背景建模技术（六）：帧处理（FrameProcessor）模块

2015-05-15 2057
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： <p>前面几篇文章简单介绍了<a target="_blank" href="http://blog.csdn.net/frd2009041510/article/details/45716009">BgsLibrary的入口函数</a>、<a target="_blank" href="http://blog.csdn.net/frd2009041510/article/details/

前面几篇文章简单介绍了BgsLibrary的入口函数、视频分析和视频捕获模块，本文将简单介绍帧处理模块，即对每一帧进行处理的函数，也就是真正调用背景建模算法的接口处。


下面贴出源码供大家分析：


#include "FrameProcessor.h"
#include <iomanip>

namespace bgslibrary
{
  FrameProcessor::FrameProcessor() : firstTime(true), frameNumber(0), duration(0), tictoc(""), frameToStop(0)
  {
    std::cout << "FrameProcessor()" << std::endl;

    loadConfig();
    saveConfig();
  }

  FrameProcessor::~FrameProcessor()
  {
    std::cout << "~FrameProcessor()" << std::endl;
  }

  void FrameProcessor::init()
  {
    if (enablePreProcessor)
      preProcessor = new PreProcessor;

    if (enableFrameDifferenceBGS)
      frameDifference = new FrameDifferenceBGS;

    if (enableStaticFrameDifferenceBGS)
      staticFrameDifference = new StaticFrameDifferenceBGS;

    if (enableWeightedMovingMeanBGS)
      weightedMovingMean = new WeightedMovingMeanBGS;

    if (enableWeightedMovingVarianceBGS)
      weightedMovingVariance = new WeightedMovingVarianceBGS;

    if (enableMixtureOfGaussianV1BGS)
      mixtureOfGaussianV1BGS = new MixtureOfGaussianV1BGS;

    if (enableMixtureOfGaussianV2BGS)
      mixtureOfGaussianV2BGS = new MixtureOfGaussianV2BGS;

    if (enableAdaptiveBackgroundLearning)
      adaptiveBackgroundLearning = new AdaptiveBackgroundLearning;

#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
    if (enableGMG)
      gmg = new GMG;
#endif

    if (enableDPAdaptiveMedianBGS)
      adaptiveMedian = new DPAdaptiveMedianBGS;

    if (enableDPGrimsonGMMBGS)
      grimsonGMM = new DPGrimsonGMMBGS;

    if (enableDPZivkovicAGMMBGS)
      zivkovicAGMM = new DPZivkovicAGMMBGS;

    if (enableDPMeanBGS)
      temporalMean = new DPMeanBGS;

    if (enableDPWrenGABGS)
      wrenGA = new DPWrenGABGS;

    if (enableDPPratiMediodBGS)
      pratiMediod = new DPPratiMediodBGS;

    if (enableDPEigenbackgroundBGS)
      eigenBackground = new DPEigenbackgroundBGS;

    if (enableDPTextureBGS)
      textureBGS = new DPTextureBGS;

    if (enableT2FGMM_UM)
      type2FuzzyGMM_UM = new T2FGMM_UM;

    if (enableT2FGMM_UV)
      type2FuzzyGMM_UV = new T2FGMM_UV;

    if (enableT2FMRF_UM)
      type2FuzzyMRF_UM = new T2FMRF_UM;

    if (enableT2FMRF_UV)
      type2FuzzyMRF_UV = new T2FMRF_UV;

    if (enableFuzzySugenoIntegral)
      fuzzySugenoIntegral = new FuzzySugenoIntegral;

    if (enableFuzzyChoquetIntegral)
      fuzzyChoquetIntegral = new FuzzyChoquetIntegral;

    if (enableLBSimpleGaussian)
      lbSimpleGaussian = new LBSimpleGaussian;

    if (enableLBFuzzyGaussian)
      lbFuzzyGaussian = new LBFuzzyGaussian;

    if (enableLBMixtureOfGaussians)
      lbMixtureOfGaussians = new LBMixtureOfGaussians;

    if (enableLBAdaptiveSOM)
      lbAdaptiveSOM = new LBAdaptiveSOM;

    if (enableLBFuzzyAdaptiveSOM)
      lbFuzzyAdaptiveSOM = new LBFuzzyAdaptiveSOM;

    if (enableLbpMrf)
      lbpMrf = new LbpMrf;

    if(enableMultiLayerBGS)
      multiLayerBGS = new MultiLayerBGS;

    //if(enablePBAS)
    //  pixelBasedAdaptiveSegmenter = new PixelBasedAdaptiveSegmenter;

    if (enableVuMeter)
      vuMeter = new VuMeter;

    if (enableKDE)
      kde = new KDE;

    if (enableIMBS)
      imbs = new IndependentMultimodalBGS;

    if (enableMultiCueBGS)
      mcbgs = new SJN_MultiCueBGS;

    if (enableSigmaDeltaBGS)
      sdbgs = new SigmaDeltaBGS;

    if (enableSuBSENSEBGS)
      ssbgs = new SuBSENSEBGS;

    if (enableLOBSTERBGS)
      lobgs = new LOBSTERBGS;

    if (enableForegroundMaskAnalysis)
      foregroundMaskAnalysis = new ForegroundMaskAnalysis;
  }

  void FrameProcessor::process(std::string name, IBGS *bgs, const cv::Mat &img_input, cv::Mat &img_bgs)
  {
    if (tictoc == name)
      tic(name);

    cv::Mat img_bkgmodel;
    bgs->process(img_input, img_bgs, img_bkgmodel);//直接调用各种背景建模算法

    if (tictoc == name)
      toc();
  }

  void FrameProcessor::process(const cv::Mat &img_input)
  {
    frameNumber++;

	///enablePreProcessor///
    if (enablePreProcessor)
      preProcessor->process(img_input, img_prep);
	
	/******************************************************************/
	/*根据config文件使能各种背景建模算法，可以同时使用多种背景建模算法*/
	/******************************************************************/
	
	///1：Frame Difference
    if (enableFrameDifferenceBGS)
      process("FrameDifferenceBGS", frameDifference, img_prep, img_framediff);
	
	///2：Static Frame Difference
    if (enableStaticFrameDifferenceBGS)
      process("StaticFrameDifferenceBGS", staticFrameDifference, img_prep, img_staticfdiff);
	
	///3：Weighted Moving Mean
    if (enableWeightedMovingMeanBGS)
      process("WeightedMovingMeanBGS", weightedMovingMean, img_prep, img_wmovmean);
	
	///4：Weighted Moving Variance
    if (enableWeightedMovingVarianceBGS)
      process("WeightedMovingVarianceBGS", weightedMovingVariance, img_prep, img_movvar);
	
	///5：Gaussian Mixture Model
    if (enableMixtureOfGaussianV1BGS)
      process("MixtureOfGaussianV1BGS", mixtureOfGaussianV1BGS, img_prep, img_mog1);
	
	///6：Gaussian Mixture Model
    if (enableMixtureOfGaussianV2BGS)
      process("MixtureOfGaussianV2BGS", mixtureOfGaussianV2BGS, img_prep, img_mog2);
	
	///7：Adaptive Background Learning
    if (enableAdaptiveBackgroundLearning)
      process("AdaptiveBackgroundLearning", adaptiveBackgroundLearning, img_prep, img_bkgl_fgmask);
	
	///8：GMG
#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
    if (enableGMG)
      process("GMG", gmg, img_prep, img_gmg);
#endif
	
	///9：Adaptive Median
    if (enableDPAdaptiveMedianBGS)
      process("DPAdaptiveMedianBGS", adaptiveMedian, img_prep, img_adpmed);
	
	///10：Gaussian Mixture Model
    if (enableDPGrimsonGMMBGS)
      process("DPGrimsonGMMBGS", grimsonGMM, img_prep, img_grigmm);
	
	///11：Gaussian Mixture Model
    if (enableDPZivkovicAGMMBGS)
      process("DPZivkovicAGMMBGS", zivkovicAGMM, img_prep, img_zivgmm);
	
	///12：Temporal Mean
    if (enableDPMeanBGS)
      process("DPMeanBGS", temporalMean, img_prep, img_tmpmean);
	
	///13：Gaussian Average
    if (enableDPWrenGABGS)
      process("DPWrenGABGS", wrenGA, img_prep, img_wrenga);
	
	///14：Temporal Median
    if (enableDPPratiMediodBGS)
      process("DPPratiMediodBGS", pratiMediod, img_prep, img_pramed);
	
	///15：Eigen background / SL-PCA
    if (enableDPEigenbackgroundBGS)
      process("DPEigenbackgroundBGS", eigenBackground, img_prep, img_eigbkg);
	
	///16：Texture BGS
    if (enableDPTextureBGS)
      process("DPTextureBGS", textureBGS, img_prep, img_texbgs);
	
	///17：Type-2 Fuzzy GMM-UM
    if (enableT2FGMM_UM)
      process("T2FGMM_UM", type2FuzzyGMM_UM, img_prep, img_t2fgmm_um);
	
	///18：Type-2 Fuzzy GMM-UV
    if (enableT2FGMM_UV)
      process("T2FGMM_UV", type2FuzzyGMM_UV, img_prep, img_t2fgmm_uv);
	
	///19：Type-2 Fuzzy GMM-UM with MRF
    if (enableT2FMRF_UM)
      process("T2FMRF_UM", type2FuzzyMRF_UM, img_prep, img_t2fmrf_um);
	
	///20：Type-2 Fuzzy GMM-UV with MRF
    if (enableT2FMRF_UV)
      process("T2FMRF_UV", type2FuzzyMRF_UV, img_prep, img_t2fmrf_uv);
	
	///21：Fuzzy Sugeno Integral
    if (enableFuzzySugenoIntegral)
      process("FuzzySugenoIntegral", fuzzySugenoIntegral, img_prep, img_fsi);
	
	///22：Fuzzy Choquet Integral
    if (enableFuzzyChoquetIntegral)
      process("FuzzyChoquetIntegral", fuzzyChoquetIntegral, img_prep, img_fci);
	
	///23：Simple Gaussian
    if (enableLBSimpleGaussian)
      process("LBSimpleGaussian", lbSimpleGaussian, img_prep, img_lb_sg);
	
	///24：Fuzzy Gaussian of Laurence Bender
    if (enableLBFuzzyGaussian)
      process("LBFuzzyGaussian", lbFuzzyGaussian, img_prep, img_lb_fg);
	
	///25：Gaussian Mixture Model
    if (enableLBMixtureOfGaussians)
      process("LBMixtureOfGaussians", lbMixtureOfGaussians, img_prep, img_lb_mog);
	
	///26：Adaptive SOM
    if (enableLBAdaptiveSOM)
      process("LBAdaptiveSOM", lbAdaptiveSOM, img_prep, img_lb_som);
	
	///27：Fuzzy Adaptive SOM
    if (enableLBFuzzyAdaptiveSOM)
      process("LBFuzzyAdaptiveSOM", lbFuzzyAdaptiveSOM, img_prep, img_lb_fsom);
	
	///28：LbpMrf
    if (enableLbpMrf)
      process("LbpMrf", lbpMrf, img_prep, img_lbp_mrf);
	
	///29：Multi-Layer BGS
    if(enableMultiLayerBGS)
    {
      multiLayerBGS->setStatus(MultiLayerBGS::MLBGS_LEARN);
      //multiLayerBGS->setStatus(MultiLayerBGS::MLBGS_DETECT);
      process("MultiLayerBGS", multiLayerBGS, img_prep, img_mlbgs);
    }
	
	///30：Pixel-Based Adaptive Segmenter
    //if(enablePBAS)
    //  process("PBAS", pixelBasedAdaptiveSegmenter, img_prep, img_pt_pbas);
	
	///31：VuMeter
    if (enableVuMeter)
      process("VuMeter", vuMeter, img_prep, img_vumeter);
	
	///32：Kernel Density Estimation
    if (enableKDE)
      process("KDE", kde, img_prep, img_kde);
	
	///33：Independent Multimodal BGS
    if (enableIMBS)
      process("IMBS", imbs, img_prep, img_imbs);
	
	///34：MultiCue BGS
    if (enableMultiCueBGS)
      process("MultiCueBGS", mcbgs, img_prep, img_mcbgs);
	
	///35：Sigma-Delta
    if (enableSigmaDeltaBGS)
      process("SigmaDeltaBGS", sdbgs, img_prep, img_sdbgs);
	
	///36：SuBSENSE
    if (enableSuBSENSEBGS)
      process("SuBSENSEBGS", ssbgs, img_prep, img_ssbgs);
	
	///37：LOBSTER
    if (enableLOBSTERBGS)
      process("LOBSTERBGS", lobgs, img_prep, img_lobgs);
	
	///enableForegroundMaskAnalysis///
    if (enableForegroundMaskAnalysis)
    {
      foregroundMaskAnalysis->stopAt = frameToStop;
      foregroundMaskAnalysis->img_ref_path = imgref;

      foregroundMaskAnalysis->process(frameNumber, "FrameDifferenceBGS", img_framediff);
      foregroundMaskAnalysis->process(frameNumber, "StaticFrameDifferenceBGS", img_staticfdiff);
      foregroundMaskAnalysis->process(frameNumber, "WeightedMovingMeanBGS", img_wmovmean);
      foregroundMaskAnalysis->process(frameNumber, "WeightedMovingVarianceBGS", img_movvar);
      foregroundMaskAnalysis->process(frameNumber, "MixtureOfGaussianV1BGS", img_mog1);
      foregroundMaskAnalysis->process(frameNumber, "MixtureOfGaussianV2BGS", img_mog2);
      foregroundMaskAnalysis->process(frameNumber, "AdaptiveBackgroundLearning", img_bkgl_fgmask);
#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
      foregroundMaskAnalysis->process(frameNumber, "GMG", img_gmg);
#endif
      foregroundMaskAnalysis->process(frameNumber, "DPAdaptiveMedianBGS", img_adpmed);
      foregroundMaskAnalysis->process(frameNumber, "DPGrimsonGMMBGS", img_grigmm);
      foregroundMaskAnalysis->process(frameNumber, "DPZivkovicAGMMBGS", img_zivgmm);
      foregroundMaskAnalysis->process(frameNumber, "DPMeanBGS", img_tmpmean);
      foregroundMaskAnalysis->process(frameNumber, "DPWrenGABGS", img_wrenga);
      foregroundMaskAnalysis->process(frameNumber, "DPPratiMediodBGS", img_pramed);
      foregroundMaskAnalysis->process(frameNumber, "DPEigenbackgroundBGS", img_eigbkg);
      foregroundMaskAnalysis->process(frameNumber, "DPTextureBGS", img_texbgs);
      foregroundMaskAnalysis->process(frameNumber, "T2FGMM_UM", img_t2fgmm_um);
      foregroundMaskAnalysis->process(frameNumber, "T2FGMM_UV", img_t2fgmm_uv);
      foregroundMaskAnalysis->process(frameNumber, "T2FMRF_UM", img_t2fmrf_um);
      foregroundMaskAnalysis->process(frameNumber, "T2FMRF_UV", img_t2fmrf_uv);
      foregroundMaskAnalysis->process(frameNumber, "FuzzySugenoIntegral", img_fsi);
      foregroundMaskAnalysis->process(frameNumber, "FuzzyChoquetIntegral", img_fci);
      foregroundMaskAnalysis->process(frameNumber, "LBSimpleGaussian", img_lb_sg);
      foregroundMaskAnalysis->process(frameNumber, "LBFuzzyGaussian", img_lb_fg);
      foregroundMaskAnalysis->process(frameNumber, "LBMixtureOfGaussians", img_lb_mog);
      foregroundMaskAnalysis->process(frameNumber, "LBAdaptiveSOM", img_lb_som);
      foregroundMaskAnalysis->process(frameNumber, "LBFuzzyAdaptiveSOM", img_lb_fsom);
      foregroundMaskAnalysis->process(frameNumber, "LbpMrf", img_lbp_mrf);
      foregroundMaskAnalysis->process(frameNumber, "MultiLayerBGS", img_mlbgs);
      //foregroundMaskAnalysis->process(frameNumber, "PBAS", img_pt_pbas);
      foregroundMaskAnalysis->process(frameNumber, "VuMeter", img_vumeter);
      foregroundMaskAnalysis->process(frameNumber, "KDE", img_kde);
      foregroundMaskAnalysis->process(frameNumber, "IMBS", img_imbs);
      foregroundMaskAnalysis->process(frameNumber, "MultiCueBGS", img_mcbgs);
      foregroundMaskAnalysis->process(frameNumber, "SigmaDeltaBGS", img_sdbgs);
      foregroundMaskAnalysis->process(frameNumber, "SuBSENSEBGS", img_ssbgs);
      foregroundMaskAnalysis->process(frameNumber, "LOBSTERBGS", img_lobgs);
    }

    firstTime = false;
  }

  void FrameProcessor::finish(void)
  {
    /*if(enableMultiLayerBGS)
    multiLayerBGS->finish();

    if(enableLBSimpleGaussian)
    lbSimpleGaussian->finish();

    if(enableLBFuzzyGaussian)
    lbFuzzyGaussian->finish();

    if(enableLBMixtureOfGaussians)
    lbMixtureOfGaussians->finish();

    if(enableLBAdaptiveSOM)
    lbAdaptiveSOM->finish();

    if(enableLBFuzzyAdaptiveSOM)
    lbFuzzyAdaptiveSOM->finish();*/

    if (enableForegroundMaskAnalysis)
      delete foregroundMaskAnalysis;

    if (enableLOBSTERBGS)
      delete lobgs;

    if (enableSuBSENSEBGS)
      delete ssbgs;

    if (enableSigmaDeltaBGS)
      delete sdbgs;

    if (enableMultiCueBGS)
      delete mcbgs;

    if (enableIMBS)
      delete imbs;

    if (enableKDE)
      delete kde;

    if (enableVuMeter)
      delete vuMeter;

    //if(enablePBAS)
    //  delete pixelBasedAdaptiveSegmenter;

    if (enableMultiLayerBGS)
      delete multiLayerBGS;

    if (enableLBFuzzyAdaptiveSOM)
      delete lbFuzzyAdaptiveSOM;

    if (enableLBAdaptiveSOM)
      delete lbAdaptiveSOM;

    if (enableLBMixtureOfGaussians)
      delete lbMixtureOfGaussians;

    if (enableLBFuzzyGaussian)
      delete lbFuzzyGaussian;

    if (enableLBSimpleGaussian)
      delete lbSimpleGaussian;

#if !defined(_WIN32)
    if (enableLbpMrf)
      delete lbpMrf;
#endif

    if(enableFuzzyChoquetIntegral)
      delete fuzzyChoquetIntegral;

    if (enableFuzzySugenoIntegral)
      delete fuzzySugenoIntegral;

    if (enableT2FMRF_UV)
      delete type2FuzzyMRF_UV;

    if (enableT2FMRF_UM)
      delete type2FuzzyMRF_UM;

    if (enableT2FGMM_UV)
      delete type2FuzzyGMM_UV;

    if (enableT2FGMM_UM)
      delete type2FuzzyGMM_UM;

    if (enableDPTextureBGS)
      delete textureBGS;

    if (enableDPEigenbackgroundBGS)
      delete eigenBackground;

    if (enableDPPratiMediodBGS)
      delete pratiMediod;

    if (enableDPWrenGABGS)
      delete wrenGA;

    if (enableDPMeanBGS)
      delete temporalMean;

    if (enableDPZivkovicAGMMBGS)
      delete zivkovicAGMM;

    if (enableDPGrimsonGMMBGS)
      delete grimsonGMM;

    if (enableDPAdaptiveMedianBGS)
      delete adaptiveMedian;

#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
    if (enableGMG)
      delete gmg;
#endif

    if (enableAdaptiveBackgroundLearning)
      delete adaptiveBackgroundLearning;

    if (enableMixtureOfGaussianV2BGS)
      delete mixtureOfGaussianV2BGS;

    if (enableMixtureOfGaussianV1BGS)
      delete mixtureOfGaussianV1BGS;

    if (enableWeightedMovingVarianceBGS)
      delete weightedMovingVariance;

    if (enableWeightedMovingMeanBGS)
      delete weightedMovingMean;

    if (enableStaticFrameDifferenceBGS)
      delete staticFrameDifference;

    if (enableFrameDifferenceBGS)
      delete frameDifference;

    if (enablePreProcessor)
      delete preProcessor;
  }

  void FrameProcessor::tic(std::string value)
  {
    processname = value;
    duration = static_cast<double>(cv::getTickCount());
  }

  void FrameProcessor::toc()
  {
    duration = (static_cast<double>(cv::getTickCount()) - duration) / cv::getTickFrequency();
    std::cout << processname << "\ttime(sec):" << std::fixed << std::setprecision(6) << duration << std::endl;
  }

  void FrameProcessor::saveConfig()
  {
    CvFileStorage* fs = cvOpenFileStorage("./config/FrameProcessor.xml", 0, CV_STORAGE_WRITE);

    cvWriteString(fs, "tictoc", tictoc.c_str());

    cvWriteInt(fs, "enablePreProcessor", enablePreProcessor);

    cvWriteInt(fs, "enableForegroundMaskAnalysis", enableForegroundMaskAnalysis);

    cvWriteInt(fs, "enableFrameDifferenceBGS", enableFrameDifferenceBGS);
    cvWriteInt(fs, "enableStaticFrameDifferenceBGS", enableStaticFrameDifferenceBGS);
    cvWriteInt(fs, "enableWeightedMovingMeanBGS", enableWeightedMovingMeanBGS);
    cvWriteInt(fs, "enableWeightedMovingVarianceBGS", enableWeightedMovingVarianceBGS);
    cvWriteInt(fs, "enableMixtureOfGaussianV1BGS", enableMixtureOfGaussianV1BGS);
    cvWriteInt(fs, "enableMixtureOfGaussianV2BGS", enableMixtureOfGaussianV2BGS);
    cvWriteInt(fs, "enableAdaptiveBackgroundLearning", enableAdaptiveBackgroundLearning);
#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
    cvWriteInt(fs, "enableGMG", enableGMG);
#endif

    cvWriteInt(fs, "enableDPAdaptiveMedianBGS", enableDPAdaptiveMedianBGS);
    cvWriteInt(fs, "enableDPGrimsonGMMBGS", enableDPGrimsonGMMBGS);
    cvWriteInt(fs, "enableDPZivkovicAGMMBGS", enableDPZivkovicAGMMBGS);
    cvWriteInt(fs, "enableDPMeanBGS", enableDPMeanBGS);
    cvWriteInt(fs, "enableDPWrenGABGS", enableDPWrenGABGS);
    cvWriteInt(fs, "enableDPPratiMediodBGS", enableDPPratiMediodBGS);
    cvWriteInt(fs, "enableDPEigenbackgroundBGS", enableDPEigenbackgroundBGS);
    cvWriteInt(fs, "enableDPTextureBGS", enableDPTextureBGS);

    cvWriteInt(fs, "enableT2FGMM_UM", enableT2FGMM_UM);
    cvWriteInt(fs, "enableT2FGMM_UV", enableT2FGMM_UV);
    cvWriteInt(fs, "enableT2FMRF_UM", enableT2FMRF_UM);
    cvWriteInt(fs, "enableT2FMRF_UV", enableT2FMRF_UV);
    cvWriteInt(fs, "enableFuzzySugenoIntegral", enableFuzzySugenoIntegral);
    cvWriteInt(fs, "enableFuzzyChoquetIntegral", enableFuzzyChoquetIntegral);

    cvWriteInt(fs, "enableLBSimpleGaussian", enableLBSimpleGaussian);
    cvWriteInt(fs, "enableLBFuzzyGaussian", enableLBFuzzyGaussian);
    cvWriteInt(fs, "enableLBMixtureOfGaussians", enableLBMixtureOfGaussians);
    cvWriteInt(fs, "enableLBAdaptiveSOM", enableLBAdaptiveSOM);
    cvWriteInt(fs, "enableLBFuzzyAdaptiveSOM", enableLBFuzzyAdaptiveSOM);

    cvWriteInt(fs, "enableLbpMrf", enableLbpMrf);

    cvWriteInt(fs, "enableMultiLayerBGS", enableMultiLayerBGS);
    //cvWriteInt(fs, "enablePBAS", enablePBAS);
    cvWriteInt(fs, "enableVuMeter", enableVuMeter);
    cvWriteInt(fs, "enableKDE", enableKDE);
    cvWriteInt(fs, "enableIMBS", enableIMBS);
    cvWriteInt(fs, "enableMultiCueBGS", enableMultiCueBGS);
    cvWriteInt(fs, "enableSigmaDeltaBGS", enableSigmaDeltaBGS);
    cvWriteInt(fs, "enableSuBSENSEBGS", enableSuBSENSEBGS);
    cvWriteInt(fs, "enableLOBSTERBGS", enableLOBSTERBGS);

    cvReleaseFileStorage(&fs);
  }

  void FrameProcessor::loadConfig()
  {
    CvFileStorage* fs = cvOpenFileStorage("./config/FrameProcessor.xml", 0, CV_STORAGE_READ);

    tictoc = cvReadStringByName(fs, 0, "tictoc", "");

    enablePreProcessor = cvReadIntByName(fs, 0, "enablePreProcessor", true);

    enableForegroundMaskAnalysis = cvReadIntByName(fs, 0, "enableForegroundMaskAnalysis", false);

    enableFrameDifferenceBGS = cvReadIntByName(fs, 0, "enableFrameDifferenceBGS", false);
    enableStaticFrameDifferenceBGS = cvReadIntByName(fs, 0, "enableStaticFrameDifferenceBGS", false);
    enableWeightedMovingMeanBGS = cvReadIntByName(fs, 0, "enableWeightedMovingMeanBGS", false);
    enableWeightedMovingVarianceBGS = cvReadIntByName(fs, 0, "enableWeightedMovingVarianceBGS", false);
    enableMixtureOfGaussianV1BGS = cvReadIntByName(fs, 0, "enableMixtureOfGaussianV1BGS", false);
    enableMixtureOfGaussianV2BGS = cvReadIntByName(fs, 0, "enableMixtureOfGaussianV2BGS", false);
    enableAdaptiveBackgroundLearning = cvReadIntByName(fs, 0, "enableAdaptiveBackgroundLearning", false);
#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
    enableGMG = cvReadIntByName(fs, 0, "enableGMG", false);
#endif

    enableDPAdaptiveMedianBGS = cvReadIntByName(fs, 0, "enableDPAdaptiveMedianBGS", false);
    enableDPGrimsonGMMBGS = cvReadIntByName(fs, 0, "enableDPGrimsonGMMBGS", false);
    enableDPZivkovicAGMMBGS = cvReadIntByName(fs, 0, "enableDPZivkovicAGMMBGS", false);
    enableDPMeanBGS = cvReadIntByName(fs, 0, "enableDPMeanBGS", false);
    enableDPWrenGABGS = cvReadIntByName(fs, 0, "enableDPWrenGABGS", false);
    enableDPPratiMediodBGS = cvReadIntByName(fs, 0, "enableDPPratiMediodBGS", false);
    enableDPEigenbackgroundBGS = cvReadIntByName(fs, 0, "enableDPEigenbackgroundBGS", false);
    enableDPTextureBGS = cvReadIntByName(fs, 0, "enableDPTextureBGS", false);

    enableT2FGMM_UM = cvReadIntByName(fs, 0, "enableT2FGMM_UM", false);
    enableT2FGMM_UV = cvReadIntByName(fs, 0, "enableT2FGMM_UV", false);
    enableT2FMRF_UM = cvReadIntByName(fs, 0, "enableT2FMRF_UM", false);
    enableT2FMRF_UV = cvReadIntByName(fs, 0, "enableT2FMRF_UV", false);
    enableFuzzySugenoIntegral = cvReadIntByName(fs, 0, "enableFuzzySugenoIntegral", false);
    enableFuzzyChoquetIntegral = cvReadIntByName(fs, 0, "enableFuzzyChoquetIntegral", false);

    enableLBSimpleGaussian = cvReadIntByName(fs, 0, "enableLBSimpleGaussian", false);
    enableLBFuzzyGaussian = cvReadIntByName(fs, 0, "enableLBFuzzyGaussian", false);
    enableLBMixtureOfGaussians = cvReadIntByName(fs, 0, "enableLBMixtureOfGaussians", false);
    enableLBAdaptiveSOM = cvReadIntByName(fs, 0, "enableLBAdaptiveSOM", false);
    enableLBFuzzyAdaptiveSOM = cvReadIntByName(fs, 0, "enableLBFuzzyAdaptiveSOM", false);

    enableLbpMrf = cvReadIntByName(fs, 0, "enableLbpMrf", false);

    enableMultiLayerBGS = cvReadIntByName(fs, 0, "enableMultiLayerBGS", false);
    //enablePBAS = cvReadIntByName(fs, 0, "enablePBAS", false);
    enableVuMeter = cvReadIntByName(fs, 0, "enableVuMeter", false);
    enableKDE = cvReadIntByName(fs, 0, "enableKDE", false);
    enableIMBS = cvReadIntByName(fs, 0, "enableIMBS", false);
    enableMultiCueBGS = cvReadIntByName(fs, 0, "enableMultiCueBGS", false);
    enableSigmaDeltaBGS = cvReadIntByName(fs, 0, "enableSigmaDeltaBGS", false);
    enableSuBSENSEBGS = cvReadIntByName(fs, 0, "enableSuBSENSEBGS", false);
    enableLOBSTERBGS = cvReadIntByName(fs, 0, "enableLOBSTERBGS", false);

    cvReleaseFileStorage(&fs);
  }
}

其实，从源码中可以看出，本函数所做的工作并不多，主要就是调用背景建模算法的接口，其接口处是：bgs->process(img_input, img_bgs, img_bkgmodel);


下面给出此段代码的大致流程框架图：







文章标签：
负载均衡
计算机视觉
Linux
算法
相关实践学习
部署高可用架构
本场景主要介绍如何使用云服务器ECS、负载均衡SLB、云数据库RDS和数据传输服务产品来部署多可用区高可用架构。
负载均衡入门与产品使用指南
负载均衡（Server Load Balancer）是对多台云服务器进行流量分发的负载均衡服务，可以通过流量分发扩展应用系统对外的服务能力，通过消除单点故障提升应用系统的可用性。 本课程主要介绍负载均衡的相关技术以及阿里云负载均衡产品的使用方法。
方瑞东
目录
相关文章
月照银海似蛟龙
|
存储 前端开发 数据可视化
3D激光SLAM：LeGO-LOAM---两步优化的帧间里程计及代码分析
**LeGO-LOAM**的全称是 Lightweight and Ground-Optimized Lidar Odometry and Mapping on Variable Terrain 其中LeGO就是轻量级和利用地面优化，轻量级的实现就是通过两步的优化方式，利用地面优化的部分也在两步优化的第一步中。 和原始LOAM一样，通过前后两帧点云来估计两帧之间的运动，从而累加得到前端里程计的输出，和上述方法使用线面约束同时优化六自由度帧间位姿不同，LeGO-LOAM的前端分成两个步骤，每个步骤估计三自由度的变量。 通过这种方式进行帧间里程计的运算，可以提供运算效率，使得可以在嵌入式平台
月照银海似蛟龙
554 0
3D激光SLAM：LeGO-LOAM---两步优化的帧间里程计及代码分析
Matlab科研工作室
|
8月前
|
机器学习/深度学习 传感器 算法
【视频处理】通过调用图像来重建新影片及计算颜色通道的平均灰度值，并检测帧与前一帧之间的差异（Matlab代码实现）
【视频处理】通过调用图像来重建新影片及计算颜色通道的平均灰度值，并检测帧与前一帧之间的差异（Matlab代码实现）
Matlab科研工作室
46 1
一米九零小胖子
|
11月前
|
传感器 算法 数据挖掘
【影像配准】多时相遥感影像配准结果模块化(附有完整代码)
【影像配准】多时相遥感影像配准结果模块化(附有完整代码)
一米九零小胖子
230 0
技术小达人
|
12月前
|
机器学习/深度学习 人工智能 达摩院
IEEE SLT 2022论文解读｜基于多帧跨通道注意力机制的多说话人语音识别
‍近期，阿里巴巴达摩院高校AIR合作论文“MFCCA:Multi-frame cross-channel attention for multi-speaker ASR in multi-party meeting scenario”被IEEE SLT 2022接收。该论文考虑到麦克风阵列不同麦克风接收信号的差异，提出了一种多帧跨通道注意力机制，该方法对相邻帧之间的跨通道信息进行建模，以利用帧级和通道级信息的互补性。
技术小达人
477 0
cdzfr5ewdwyaw
|
12月前
|
机器学习/深度学习 传感器 算法
目标检测+目标追踪+单目测距（毕设+代码）下
目标检测+目标追踪+单目测距（毕设+代码）
cdzfr5ewdwyaw
188 0
cdzfr5ewdwyaw
|
12月前
|
机器学习/深度学习 算法 自动驾驶
目标检测+目标追踪+单目测距（毕设+代码）上
目标检测+目标追踪+单目测距（毕设+代码）
cdzfr5ewdwyaw
250 0
技术小达人
|
机器学习/深度学习 人工智能 编解码
CVPR 2022 | 逆渲染中的⾼效间接光照建模
CVPR 2022 | 逆渲染中的⾼效间接光照建模
技术小达人
475 0
CVPR 2022 | 逆渲染中的⾼效间接光照建模
游客iigf2m33ba53k
|
编解码 人工智能 算法
最新代码开源！TartanCalib：自适应亚像素细化的广角镜头标定
作者测试了三种利用中间相机模型的关键方法：（1）将图像分解为虚拟针孔相机，（2）将目标重新投影到图像帧中，以及（3）自适应亚像素细化。将自适应子像素细化和特征重投影相结合，可将重投影误差显著提高26.59%，帮助检测到最多42.01%的特征，并提高密集深度映射下游任务的性能。最后，TartanCalib是开源的，并在一个易于使用的标定工具箱中实现。作者还提供了一个translation 层和其它最先进的工作，允许使用数千个参数回归通用模型或使用更稳健的求解器。为此，TartanCalib是广角标定的首选工具！
游客iigf2m33ba53k
350 0
最新代码开源！TartanCalib：自适应亚像素细化的广角镜头标定
Deephub
|
机器学习/深度学习 编解码 计算机视觉
可变形卷积在视频学习中的应用:如何利用带有稀疏标记数据的视频帧
可变形卷积在视频学习中的应用:如何利用带有稀疏标记数据的视频帧
Deephub
144 0
可变形卷积在视频学习中的应用:如何利用带有稀疏标记数据的视频帧
我爱matlab
|
算法
基于基于全局差错能量函数的双目图像立体匹配算法matlab仿真,并提取图像的深度信息
基于基于全局差错能量函数的双目图像立体匹配算法matlab仿真,并提取图像的深度信息
我爱matlab
140 0
基于基于全局差错能量函数的双目图像立体匹配算法matlab仿真,并提取图像的深度信息

热门文章

最新文章

  • 1
    解决关于Windows Defender Antivirus Service自启造成运行python程序时，Windows的cpu和内存占用过高问题
  • 2
    订票系统不再瘫痪 阿里云确认与12306合作
  • 3
    iOS - 手动下架的应用后快速恢复上架
  • 4
    du 和 df以及lsof
  • 5
    库克：苹果不是只做富人生意，还一直坚持让世界变得更好
  • 6
    WiGig无线标准正式开始提供验证 最高可达8Gbps
  • 7
    IBM推出新的16位量子处理器
  • 8
    Android:随笔——对页面的View进行截图
  • 9
    shell MAC 地址 校验
  • 10
    【系统优化】数据库系统load飙高问题解决思路
  • 1
    DataWorks产品使用合集之DataWorks中，如果一个虚拟节点被设置为冻结状态，那么它的所有子节点也将被冻结如何解决
    24
  • 2
    DataWorks产品使用合集之DataWorks发布任务的方法如何解决
    25
  • 3
    DataWorks产品使用合集之DataWorks中，配置DataHub数据源如何解决
    23
  • 4
    Nacos 1.4.1核心功能组件及使用入门
    22
  • 5
    DataWorks产品使用合集之在 DataWorks 中，有一个 MySQL 数据表，数据量非常大且数据会不断更新将这些数据同步到 DataWorks如何解决
    14
  • 6
    基于直方图的图像阈值计算和分割算法FPGA实现,包含tb测试文件和MATLAB辅助验证
    14
  • 7
    DataWorks产品使用合集之在DataWorks中，要实现MySQL数据源的增量同步如何解决
    17

    • 相关电子书

    更多
  • 数据共享 解码真实世界
  • 深度学习论文实现：空间变换网络-第一部分
  • 基于神经网络的语言合成

    • 相关实验场景

    更多
  • 流密码与线性反馈移位寄存器LFSR
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考