-
Andrews Sobral authoredAndrews Sobral authored
Code owners
Assign users and groups as approvers for specific file changes. Learn more.
FrameProcessor.cpp 21.73 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 (enableFrameDifference)
frameDifference = new FrameDifference;
if (enableStaticFrameDifference)
staticFrameDifference = new StaticFrameDifference;
if (enableWeightedMovingMean)
weightedMovingMean = new WeightedMovingMean;
if (enableWeightedMovingVariance)
weightedMovingVariance = new WeightedMovingVariance;
#if CV_MAJOR_VERSION == 2
if (enableMixtureOfGaussianV1)
mixtureOfGaussianV1 = new MixtureOfGaussianV1;
#endif
if (enableMixtureOfGaussianV2)
mixtureOfGaussianV2 = new MixtureOfGaussianV2;
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 (enableDPAdaptiveMedian)
dpAdaptiveMedian = new DPAdaptiveMedian;
if (enableDPGrimsonGMM)
dpGrimsonGMM = new DPGrimsonGMM;
if (enableDPZivkovicAGMM)
dpZivkovicAGMM = new DPZivkovicAGMM;
if (enableDPMean)
dpTemporalMean = new DPMean;
if (enableDPWrenGA)
dpWrenGA = new DPWrenGA;
if (enableDPPratiMediod)
dpPratiMediod = new DPPratiMediod;
if (enableDPEigenbackground)
dpEigenBackground = new DPEigenbackground;
if (enableDPTexture)
dpTexture = new DPTexture;
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 LBP_MRF;
#if CV_MAJOR_VERSION == 2
if (enableMultiLayer)
multiLayer = new MultiLayer;
#endif
if (enablePBAS)
pixelBasedAdaptiveSegmenter = new PixelBasedAdaptiveSegmenter;
if (enableVuMeter)
vuMeter = new VuMeter;
if (enableKDE)
kde = new KDE;
if (enableIMBS)
imbs = new IndependentMultimodal;
if (enableMultiCue)
multiCue = new MultiCue;
if (enableSigmaDelta)
sigmaDelta = new SigmaDelta;
if (enableSuBSENSE)
subSENSE = new SuBSENSE;
if (enableLOBSTER)
lobster = new LOBSTER;
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_preProcessor);
if (enableFrameDifference)
process("FrameDifference", frameDifference, img_preProcessor, img_frameDifference);
if (enableStaticFrameDifference)
process("StaticFrameDifference", staticFrameDifference, img_preProcessor, img_staticFrameDifference);
if (enableWeightedMovingMean)
process("WeightedMovingMean", weightedMovingMean, img_preProcessor, img_weightedMovingMean);
if (enableWeightedMovingVariance)
process("WeightedMovingVariance", weightedMovingVariance, img_preProcessor, img_weightedMovingVariance);
#if CV_MAJOR_VERSION == 2
if (enableMixtureOfGaussianV1)
process("MixtureOfGaussianV1", mixtureOfGaussianV1, img_preProcessor, img_mixtureOfGaussianV1);
#endif
if (enableMixtureOfGaussianV2)
process("MixtureOfGaussianV2", mixtureOfGaussianV2, img_preProcessor, img_mixtureOfGaussianV2);
if (enableAdaptiveBackgroundLearning)
process("AdaptiveBackgroundLearning", adaptiveBackgroundLearning, img_preProcessor, img_adaptiveBackgroundLearning);
#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
if (enableGMG)
process("GMG", gmg, img_preProcessor, img_gmg);
#endif
if (enableDPAdaptiveMedian)
process("DPAdaptiveMedian", dpAdaptiveMedian, img_preProcessor, img_dpAdaptiveMedian);
if (enableDPGrimsonGMM)
process("DPGrimsonGMM", dpGrimsonGMM, img_preProcessor, img_dpGrimsonGMM);
if (enableDPZivkovicAGMM)
process("DPZivkovicAGMM", dpZivkovicAGMM, img_preProcessor, img_dpZivkovicAGMM);
if (enableDPMean)
process("DPMean", dpTemporalMean, img_preProcessor, img_dpTemporalMean);
if (enableDPWrenGA)
process("DPWrenGA", dpWrenGA, img_preProcessor, img_dpWrenGA);
if (enableDPPratiMediod)
process("DPPratiMediod", dpPratiMediod, img_preProcessor, img_dpPratiMediod);
if (enableDPEigenbackground)
process("DPEigenbackground", dpEigenBackground, img_preProcessor, img_dpEigenBackground);
if (enableDPTexture)
process("DPTexture", dpTexture, img_preProcessor, img_dpTexture);
if (enableT2FGMM_UM)
process("T2FGMM_UM", type2FuzzyGMM_UM, img_preProcessor, img_type2FuzzyGMM_UM);
if (enableT2FGMM_UV)
process("T2FGMM_UV", type2FuzzyGMM_UV, img_preProcessor, img_type2FuzzyGMM_UV);
if (enableT2FMRF_UM)
process("T2FMRF_UM", type2FuzzyMRF_UM, img_preProcessor, img_type2FuzzyMRF_UM);
if (enableT2FMRF_UV)
process("T2FMRF_UV", type2FuzzyMRF_UV, img_preProcessor, img_type2FuzzyMRF_UV);
if (enableFuzzySugenoIntegral)
process("FuzzySugenoIntegral", fuzzySugenoIntegral, img_preProcessor, img_fuzzySugenoIntegral);
if (enableFuzzyChoquetIntegral)
process("FuzzyChoquetIntegral", fuzzyChoquetIntegral, img_preProcessor, img_fuzzyChoquetIntegral);
if (enableLBSimpleGaussian)
process("LBSimpleGaussian", lbSimpleGaussian, img_preProcessor, img_lbSimpleGaussian);
if (enableLBFuzzyGaussian)
process("LBFuzzyGaussian", lbFuzzyGaussian, img_preProcessor, img_lbFuzzyGaussian);
if (enableLBMixtureOfGaussians)
process("LBMixtureOfGaussians", lbMixtureOfGaussians, img_preProcessor, img_lbMixtureOfGaussians);
if (enableLBAdaptiveSOM)
process("LBAdaptiveSOM", lbAdaptiveSOM, img_preProcessor, img_lbAdaptiveSOM);
if (enableLBFuzzyAdaptiveSOM)
process("LBFuzzyAdaptiveSOM", lbFuzzyAdaptiveSOM, img_preProcessor, img_lbFuzzyAdaptiveSOM);
if (enableLbpMrf)
process("LbpMrf", lbpMrf, img_preProcessor, img_lbpMrf);
#if CV_MAJOR_VERSION == 2
if (enableMultiLayer)
{
multiLayer->setStatus(MultiLayer::MLBGS_LEARN);
//multiLayer->setStatus(MultiLayer::MLBGS_DETECT);
process("MultiLayer", multiLayer, img_preProcessor, img_multiLayer);
}
#endif
if (enablePBAS)
process("PBAS", pixelBasedAdaptiveSegmenter, img_preProcessor, img_pixelBasedAdaptiveSegmenter);
if (enableVuMeter)
process("VuMeter", vuMeter, img_preProcessor, img_vumeter);
if (enableKDE)
process("KDE", kde, img_preProcessor, img_kde);
if (enableIMBS)
process("IMBS", imbs, img_preProcessor, img_imbs);
if (enableMultiCue)
process("MultiCue", multiCue, img_preProcessor, img_multiCue);
if (enableSigmaDelta)
process("SigmaDelta", sigmaDelta, img_preProcessor, img_sigmaDelta);
if (enableSuBSENSE)
process("SuBSENSE", subSENSE, img_preProcessor, img_subSENSE);
if (enableLOBSTER)
process("LOBSTER", lobster, img_preProcessor, img_lobster);
if (enableForegroundMaskAnalysis)
{
foregroundMaskAnalysis->stopAt = frameToStop;
foregroundMaskAnalysis->img_ref_path = imgref;
foregroundMaskAnalysis->process(frameNumber, "FrameDifference", img_frameDifference);
foregroundMaskAnalysis->process(frameNumber, "StaticFrameDifference", img_staticFrameDifference);
foregroundMaskAnalysis->process(frameNumber, "WeightedMovingMean", img_weightedMovingMean);
foregroundMaskAnalysis->process(frameNumber, "WeightedMovingVariance", img_weightedMovingVariance);
#if CV_MAJOR_VERSION == 2
foregroundMaskAnalysis->process(frameNumber, "MixtureOfGaussianV1", img_mixtureOfGaussianV1);
#endif
foregroundMaskAnalysis->process(frameNumber, "MixtureOfGaussianV2", img_mixtureOfGaussianV2);
foregroundMaskAnalysis->process(frameNumber, "AdaptiveBackgroundLearning", img_adaptiveBackgroundLearning);
#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
foregroundMaskAnalysis->process(frameNumber, "GMG", img_gmg);
#endif
foregroundMaskAnalysis->process(frameNumber, "DPAdaptiveMedian", img_dpAdaptiveMedian);
foregroundMaskAnalysis->process(frameNumber, "DPGrimsonGMM", img_dpGrimsonGMM);
foregroundMaskAnalysis->process(frameNumber, "DPZivkovicAGMM", img_dpZivkovicAGMM);
foregroundMaskAnalysis->process(frameNumber, "DPMean", img_dpTemporalMean);
foregroundMaskAnalysis->process(frameNumber, "DPWrenGA", img_dpWrenGA);
foregroundMaskAnalysis->process(frameNumber, "DPPratiMediod", img_dpPratiMediod);
foregroundMaskAnalysis->process(frameNumber, "DPEigenbackground", img_dpEigenBackground);
foregroundMaskAnalysis->process(frameNumber, "DPTexture", img_dpTexture);
foregroundMaskAnalysis->process(frameNumber, "T2FGMM_UM", img_type2FuzzyGMM_UM);
foregroundMaskAnalysis->process(frameNumber, "T2FGMM_UV", img_type2FuzzyGMM_UV);
foregroundMaskAnalysis->process(frameNumber, "T2FMRF_UM", img_type2FuzzyMRF_UM);
foregroundMaskAnalysis->process(frameNumber, "T2FMRF_UV", img_type2FuzzyMRF_UV);
foregroundMaskAnalysis->process(frameNumber, "FuzzySugenoIntegral", img_fuzzySugenoIntegral);
foregroundMaskAnalysis->process(frameNumber, "FuzzyChoquetIntegral", img_fuzzyChoquetIntegral);
foregroundMaskAnalysis->process(frameNumber, "LBSimpleGaussian", img_lbSimpleGaussian);
foregroundMaskAnalysis->process(frameNumber, "LBFuzzyGaussian", img_lbFuzzyGaussian);
foregroundMaskAnalysis->process(frameNumber, "LBMixtureOfGaussians", img_lbMixtureOfGaussians);
foregroundMaskAnalysis->process(frameNumber, "LBAdaptiveSOM", img_lbAdaptiveSOM);
foregroundMaskAnalysis->process(frameNumber, "LBFuzzyAdaptiveSOM", img_lbFuzzyAdaptiveSOM);
foregroundMaskAnalysis->process(frameNumber, "LbpMrf", img_lbpMrf);
#if CV_MAJOR_VERSION == 2
foregroundMaskAnalysis->process(frameNumber, "MultiLayer", img_multiLayer);
#endif
foregroundMaskAnalysis->process(frameNumber, "PBAS", img_pixelBasedAdaptiveSegmenter);
foregroundMaskAnalysis->process(frameNumber, "VuMeter", img_vumeter);
foregroundMaskAnalysis->process(frameNumber, "KDE", img_kde);
foregroundMaskAnalysis->process(frameNumber, "IMBS", img_imbs);
foregroundMaskAnalysis->process(frameNumber, "MultiCue", img_multiCue);
foregroundMaskAnalysis->process(frameNumber, "SigmaDelta", img_sigmaDelta);
foregroundMaskAnalysis->process(frameNumber, "SuBSENSE", img_subSENSE);
foregroundMaskAnalysis->process(frameNumber, "LOBSTER", img_lobster);
}
firstTime = false;
}
void FrameProcessor::finish(void)
{
/*if(enableMultiLayer)
multiLayer->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 (enableLOBSTER)
delete lobster;
if (enableSuBSENSE)
delete subSENSE;
if (enableSigmaDelta)
delete sigmaDelta;
if (enableMultiCue)
delete multiCue;
if (enableIMBS)
delete imbs;
if (enableKDE)
delete kde;
if (enableVuMeter)
delete vuMeter;
if (enablePBAS)
delete pixelBasedAdaptiveSegmenter;
#if CV_MAJOR_VERSION == 2
if (enableMultiLayer)
delete multiLayer;
#endif
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 (enableDPTexture)
delete dpTexture;
if (enableDPEigenbackground)
delete dpEigenBackground;
if (enableDPPratiMediod)
delete dpPratiMediod;
if (enableDPWrenGA)
delete dpWrenGA;
if (enableDPMean)
delete dpTemporalMean;
if (enableDPZivkovicAGMM)
delete dpZivkovicAGMM;
if (enableDPGrimsonGMM)
delete dpGrimsonGMM;
if (enableDPAdaptiveMedian)
delete dpAdaptiveMedian;
#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
if (enableGMG)
delete gmg;
#endif
if (enableAdaptiveBackgroundLearning)
delete adaptiveBackgroundLearning;
if (enableMixtureOfGaussianV2)
delete mixtureOfGaussianV2;
#if CV_MAJOR_VERSION == 2
if (enableMixtureOfGaussianV1)
delete mixtureOfGaussianV1;
#endif
if (enableWeightedMovingVariance)
delete weightedMovingVariance;
if (enableWeightedMovingMean)
delete weightedMovingMean;
if (enableStaticFrameDifference)
delete staticFrameDifference;
if (enableFrameDifference)
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, "enableFrameDifference", enableFrameDifference);
cvWriteInt(fs, "enableStaticFrameDifference", enableStaticFrameDifference);
cvWriteInt(fs, "enableWeightedMovingMean", enableWeightedMovingMean);
cvWriteInt(fs, "enableWeightedMovingVariance", enableWeightedMovingVariance);
#if CV_MAJOR_VERSION == 2
cvWriteInt(fs, "enableMixtureOfGaussianV1", enableMixtureOfGaussianV1);
#endif
cvWriteInt(fs, "enableMixtureOfGaussianV2", enableMixtureOfGaussianV2);
cvWriteInt(fs, "enableAdaptiveBackgroundLearning", enableAdaptiveBackgroundLearning);
#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
cvWriteInt(fs, "enableGMG", enableGMG);
#endif
cvWriteInt(fs, "enableDPAdaptiveMedian", enableDPAdaptiveMedian);
cvWriteInt(fs, "enableDPGrimsonGMM", enableDPGrimsonGMM);
cvWriteInt(fs, "enableDPZivkovicAGMM", enableDPZivkovicAGMM);
cvWriteInt(fs, "enableDPMean", enableDPMean);
cvWriteInt(fs, "enableDPWrenGA", enableDPWrenGA);
cvWriteInt(fs, "enableDPPratiMediod", enableDPPratiMediod);
cvWriteInt(fs, "enableDPEigenbackground", enableDPEigenbackground);
cvWriteInt(fs, "enableDPTexture", enableDPTexture);
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);
#if CV_MAJOR_VERSION == 2
cvWriteInt(fs, "enableMultiLayer", enableMultiLayer);
#endif
cvWriteInt(fs, "enablePBAS", enablePBAS);
cvWriteInt(fs, "enableVuMeter", enableVuMeter);
cvWriteInt(fs, "enableKDE", enableKDE);
cvWriteInt(fs, "enableIMBS", enableIMBS);
cvWriteInt(fs, "enableMultiCue", enableMultiCue);
cvWriteInt(fs, "enableSigmaDelta", enableSigmaDelta);
cvWriteInt(fs, "enableSuBSENSE", enableSuBSENSE);
cvWriteInt(fs, "enableLOBSTER", enableLOBSTER);
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);
enableFrameDifference = cvReadIntByName(fs, 0, "enableFrameDifference", false);
enableStaticFrameDifference = cvReadIntByName(fs, 0, "enableStaticFrameDifference", false);
enableWeightedMovingMean = cvReadIntByName(fs, 0, "enableWeightedMovingMean", false);
enableWeightedMovingVariance = cvReadIntByName(fs, 0, "enableWeightedMovingVariance", false);
#if CV_MAJOR_VERSION == 2
enableMixtureOfGaussianV1 = cvReadIntByName(fs, 0, "enableMixtureOfGaussianV1", false);
#endif
enableMixtureOfGaussianV2 = cvReadIntByName(fs, 0, "enableMixtureOfGaussianV2", 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
enableDPAdaptiveMedian = cvReadIntByName(fs, 0, "enableDPAdaptiveMedian", false);
enableDPGrimsonGMM = cvReadIntByName(fs, 0, "enableDPGrimsonGMM", false);
enableDPZivkovicAGMM = cvReadIntByName(fs, 0, "enableDPZivkovicAGMM", false);
enableDPMean = cvReadIntByName(fs, 0, "enableDPMean", false);
enableDPWrenGA = cvReadIntByName(fs, 0, "enableDPWrenGA", false);
enableDPPratiMediod = cvReadIntByName(fs, 0, "enableDPPratiMediod", false);
enableDPEigenbackground = cvReadIntByName(fs, 0, "enableDPEigenbackground", false);
enableDPTexture = cvReadIntByName(fs, 0, "enableDPTexture", 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);
#if CV_MAJOR_VERSION == 2
enableMultiLayer = cvReadIntByName(fs, 0, "enableMultiLayer", false);
#endif
enablePBAS = cvReadIntByName(fs, 0, "enablePBAS", false);
enableVuMeter = cvReadIntByName(fs, 0, "enableVuMeter", false);
enableKDE = cvReadIntByName(fs, 0, "enableKDE", false);
enableIMBS = cvReadIntByName(fs, 0, "enableIMBS", false);
enableMultiCue = cvReadIntByName(fs, 0, "enableMultiCue", false);
enableSigmaDelta = cvReadIntByName(fs, 0, "enableSigmaDelta", false);
enableSuBSENSE = cvReadIntByName(fs, 0, "enableSuBSENSE", false);
enableLOBSTER = cvReadIntByName(fs, 0, "enableLOBSTER", false);
cvReleaseFileStorage(&fs);
}
}