Skip to content
Snippets Groups Projects
Select Git revision
  • 40d7b0736592ea57a9d53abafdbb7643174ac7e5
  • main default
  • krausec-main-patch-16624
  • fixes-typo-2025-04-14
  • fixes-typo-2025-03-27
  • fixes-typo-2025u
  • fixes-typo-19
  • fixes-typo-9
  • fixes-typo-8
  • wip/project-management
  • wip/config-paste
  • lfs
12 results

git-course.html

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    FrameProcessor.cpp 20.39 KiB
    /*
    This file is part of BGSLibrary.
    
    BGSLibrary is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    BGSLibrary is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with BGSLibrary.  If not, see <http://www.gnu.org/licenses/>.
    */
    #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 !defined(_WIN32)
        if (enableLbpMrf)
          lbpMrf = new LbpMrf;
    #endif
    
        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 (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++;
    
        if (enablePreProcessor)
          preProcessor->process(img_input, img_prep);
    
        if (enableFrameDifferenceBGS)
          process("FrameDifferenceBGS", frameDifference, img_prep, img_framediff);
    
        if (enableStaticFrameDifferenceBGS)
          process("StaticFrameDifferenceBGS", staticFrameDifference, img_prep, img_staticfdiff);
    
        if (enableWeightedMovingMeanBGS)
          process("WeightedMovingMeanBGS", weightedMovingMean, img_prep, img_wmovmean);
    
        if (enableWeightedMovingVarianceBGS)
          process("WeightedMovingVarianceBGS", weightedMovingVariance, img_prep, img_movvar);
    
        if (enableMixtureOfGaussianV1BGS)
          process("MixtureOfGaussianV1BGS", mixtureOfGaussianV1BGS, img_prep, img_mog1);
    
        if (enableMixtureOfGaussianV2BGS)
          process("MixtureOfGaussianV2BGS", mixtureOfGaussianV2BGS, img_prep, img_mog2);
    
        if (enableAdaptiveBackgroundLearning)
          process("AdaptiveBackgroundLearning", adaptiveBackgroundLearning, img_prep, img_bkgl_fgmask);
    
    #if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
        if (enableGMG)
          process("GMG", gmg, img_prep, img_gmg);
    #endif
    
        if (enableDPAdaptiveMedianBGS)
          process("DPAdaptiveMedianBGS", adaptiveMedian, img_prep, img_adpmed);
    
        if (enableDPGrimsonGMMBGS)
          process("DPGrimsonGMMBGS", grimsonGMM, img_prep, img_grigmm);
    
        if (enableDPZivkovicAGMMBGS)
          process("DPZivkovicAGMMBGS", zivkovicAGMM, img_prep, img_zivgmm);
    
        if (enableDPMeanBGS)
          process("DPMeanBGS", temporalMean, img_prep, img_tmpmean);
    
        if (enableDPWrenGABGS)
          process("DPWrenGABGS", wrenGA, img_prep, img_wrenga);
    
        if (enableDPPratiMediodBGS)
          process("DPPratiMediodBGS", pratiMediod, img_prep, img_pramed);
    
        if (enableDPEigenbackgroundBGS)
          process("DPEigenbackgroundBGS", eigenBackground, img_prep, img_eigbkg);
    
        if (enableDPTextureBGS)
          process("DPTextureBGS", textureBGS, img_prep, img_texbgs);
    
        if (enableT2FGMM_UM)
          process("T2FGMM_UM", type2FuzzyGMM_UM, img_prep, img_t2fgmm_um);
    
        if (enableT2FGMM_UV)
          process("T2FGMM_UV", type2FuzzyGMM_UV, img_prep, img_t2fgmm_uv);
    
        if (enableT2FMRF_UM)
          process("T2FMRF_UM", type2FuzzyMRF_UM, img_prep, img_t2fmrf_um);
    
        if (enableT2FMRF_UV)
          process("T2FMRF_UV", type2FuzzyMRF_UV, img_prep, img_t2fmrf_uv);
    
        if (enableFuzzySugenoIntegral)
          process("FuzzySugenoIntegral", fuzzySugenoIntegral, img_prep, img_fsi);
    
        if (enableFuzzyChoquetIntegral)
          process("FuzzyChoquetIntegral", fuzzyChoquetIntegral, img_prep, img_fci);
    
        if (enableLBSimpleGaussian)
          process("LBSimpleGaussian", lbSimpleGaussian, img_prep, img_lb_sg);
    
        if (enableLBFuzzyGaussian)
          process("LBFuzzyGaussian", lbFuzzyGaussian, img_prep, img_lb_fg);
    
        if (enableLBMixtureOfGaussians)
          process("LBMixtureOfGaussians", lbMixtureOfGaussians, img_prep, img_lb_mog);
    
        if (enableLBAdaptiveSOM)
          process("LBAdaptiveSOM", lbAdaptiveSOM, img_prep, img_lb_som);
    
        if (enableLBFuzzyAdaptiveSOM)
          process("LBFuzzyAdaptiveSOM", lbFuzzyAdaptiveSOM, img_prep, img_lb_fsom);
    
    #if !defined(_WIN32)
        if (enableLbpMrf)
          process("LbpMrf", lbpMrf, img_prep, img_lbp_mrf);
    #endif
    
        if(enableMultiLayerBGS)
        {
          multiLayerBGS->setStatus(MultiLayerBGS::Status::MLBGS_LEARN);
          //multiLayerBGS->setStatus(MultiLayerBGS::Status::MLBGS_DETECT);
          process("MultiLayerBGS", multiLayerBGS, img_prep, img_mlbgs);
        }
    
        //if(enablePBAS)
        //  process("PBAS", pixelBasedAdaptiveSegmenter, img_prep, img_pt_pbas);
    
        if (enableVuMeter)
          process("VuMeter", vuMeter, img_prep, img_vumeter);
    
        if (enableKDE)
          process("KDE", kde, img_prep, img_kde);
    
        if (enableIMBS)
          process("IMBS", imbs, img_prep, img_imbs);
    
        if (enableMultiCueBGS)
          process("MultiCueBGS", mcbgs, img_prep, img_mcbgs);
    
        if (enableSigmaDeltaBGS)
          process("SigmaDeltaBGS", sdbgs, img_prep, img_sdbgs);
    
        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);
    #if !defined(_WIN32)
          foregroundMaskAnalysis->process(frameNumber, "LbpMrf", img_lbp_mrf);
    #endif
          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);
        }
    
        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 (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);
    
    #if !defined(_WIN32)
        cvWriteInt(fs, "enableLbpMrf", enableLbpMrf);
    #endif
    
        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);
    
        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);
    
    #if !defined(_WIN32)
        enableLbpMrf = cvReadIntByName(fs, 0, "enableLbpMrf", false);
    #endif
    
        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);
    
        cvReleaseFileStorage(&fs);
      }
    }