diff --git a/Config.h b/Config.h
index 01cf7210a47f3682e5e8010311a4f8fc11b0bedd..61a992d91961a77e1d13b7f3963d9bb46b05145a 100644
--- a/Config.h
+++ b/Config.h
@@ -16,7 +16,10 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
-const int KEY_REPEAT = 'r';
-const int KEY_SPACE = 32;
-const int KEY_ESC = 27;
-const int KEY_ESC2 = 'q';
+namespace bgslibrary
+{
+ const int KEY_REPEAT = 'r';
+ const int KEY_SPACE = 32;
+ const int KEY_ESC = 27;
+ const int KEY_ESC2 = 'q';
+}
diff --git a/FrameProcessor.cpp b/FrameProcessor.cpp
index 72cea5b4fcd3dd48cb8c5aaafc13ffab310f867d..9f9bc28b902eca80cb5ca822c86950d96723b7b2 100644
--- a/FrameProcessor.cpp
+++ b/FrameProcessor.cpp
@@ -16,542 +16,569 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
*/
#include "FrameProcessor.h"
-FrameProcessor::FrameProcessor() : firstTime(true), frameNumber(0), duration(0), tictoc(""), frameToStop(0)
+namespace bgslibrary
{
- std::cout << "FrameProcessor()" << std::endl;
+ FrameProcessor::FrameProcessor() : firstTime(true), frameNumber(0), duration(0), tictoc(""), frameToStop(0)
+ {
+ std::cout << "FrameProcessor()" << std::endl;
- loadConfig();
- saveConfig();
-}
+ loadConfig();
+ saveConfig();
+ }
-FrameProcessor::~FrameProcessor()
-{
- std::cout << "~FrameProcessor()" << std::endl;
-}
+ FrameProcessor::~FrameProcessor()
+ {
+ std::cout << "~FrameProcessor()" << std::endl;
+ }
-void FrameProcessor::init()
-{
- if(enablePreProcessor)
- preProcessor = new PreProcessor;
+ void FrameProcessor::init()
+ {
+ if (enablePreProcessor)
+ preProcessor = new PreProcessor;
- if(enableFrameDifferenceBGS)
- frameDifference = new FrameDifferenceBGS;
+ if (enableFrameDifferenceBGS)
+ frameDifference = new FrameDifferenceBGS;
- if(enableStaticFrameDifferenceBGS)
- staticFrameDifference = new StaticFrameDifferenceBGS;
+ if (enableStaticFrameDifferenceBGS)
+ staticFrameDifference = new StaticFrameDifferenceBGS;
- if(enableWeightedMovingMeanBGS)
- weightedMovingMean = new WeightedMovingMeanBGS;
+ if (enableWeightedMovingMeanBGS)
+ weightedMovingMean = new WeightedMovingMeanBGS;
- if(enableWeightedMovingVarianceBGS)
- weightedMovingVariance = new WeightedMovingVarianceBGS;
+ if (enableWeightedMovingVarianceBGS)
+ weightedMovingVariance = new WeightedMovingVarianceBGS;
- if(enableMixtureOfGaussianV1BGS)
- mixtureOfGaussianV1BGS = new MixtureOfGaussianV1BGS;
+ if (enableMixtureOfGaussianV1BGS)
+ mixtureOfGaussianV1BGS = new MixtureOfGaussianV1BGS;
- if(enableMixtureOfGaussianV2BGS)
- mixtureOfGaussianV2BGS = new MixtureOfGaussianV2BGS;
+ if (enableMixtureOfGaussianV2BGS)
+ mixtureOfGaussianV2BGS = new MixtureOfGaussianV2BGS;
- if(enableAdaptiveBackgroundLearning)
- adaptiveBackgroundLearning = new AdaptiveBackgroundLearning;
+ if (enableAdaptiveBackgroundLearning)
+ adaptiveBackgroundLearning = new AdaptiveBackgroundLearning;
#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
- if(enableGMG)
- gmg = new GMG;
+ if (enableGMG)
+ gmg = new GMG;
#endif
- if(enableDPAdaptiveMedianBGS)
- adaptiveMedian = new DPAdaptiveMedianBGS;
+ if (enableDPAdaptiveMedianBGS)
+ adaptiveMedian = new DPAdaptiveMedianBGS;
- if(enableDPGrimsonGMMBGS)
- grimsonGMM = new DPGrimsonGMMBGS;
+ if (enableDPGrimsonGMMBGS)
+ grimsonGMM = new DPGrimsonGMMBGS;
- if(enableDPZivkovicAGMMBGS)
- zivkovicAGMM = new DPZivkovicAGMMBGS;
+ if (enableDPZivkovicAGMMBGS)
+ zivkovicAGMM = new DPZivkovicAGMMBGS;
- if(enableDPMeanBGS)
- temporalMean = new DPMeanBGS;
+ if (enableDPMeanBGS)
+ temporalMean = new DPMeanBGS;
- if(enableDPWrenGABGS)
- wrenGA = new DPWrenGABGS;
+ if (enableDPWrenGABGS)
+ wrenGA = new DPWrenGABGS;
- if(enableDPPratiMediodBGS)
- pratiMediod = new DPPratiMediodBGS;
+ if (enableDPPratiMediodBGS)
+ pratiMediod = new DPPratiMediodBGS;
- if(enableDPEigenbackgroundBGS)
- eigenBackground = new DPEigenbackgroundBGS;
+ if (enableDPEigenbackgroundBGS)
+ eigenBackground = new DPEigenbackgroundBGS;
- if(enableDPTextureBGS)
- textureBGS = new DPTextureBGS;
+ if (enableDPTextureBGS)
+ textureBGS = new DPTextureBGS;
- if(enableT2FGMM_UM)
- type2FuzzyGMM_UM = new T2FGMM_UM;
+ if (enableT2FGMM_UM)
+ type2FuzzyGMM_UM = new T2FGMM_UM;
- if(enableT2FGMM_UV)
- type2FuzzyGMM_UV = new T2FGMM_UV;
+ if (enableT2FGMM_UV)
+ type2FuzzyGMM_UV = new T2FGMM_UV;
- if(enableT2FMRF_UM)
- type2FuzzyMRF_UM = new T2FMRF_UM;
+ if (enableT2FMRF_UM)
+ type2FuzzyMRF_UM = new T2FMRF_UM;
- if(enableT2FMRF_UV)
- type2FuzzyMRF_UV = new T2FMRF_UV;
+ if (enableT2FMRF_UV)
+ type2FuzzyMRF_UV = new T2FMRF_UV;
- if(enableFuzzySugenoIntegral)
- fuzzySugenoIntegral = new FuzzySugenoIntegral;
+ if (enableFuzzySugenoIntegral)
+ fuzzySugenoIntegral = new FuzzySugenoIntegral;
- if(enableFuzzyChoquetIntegral)
- fuzzyChoquetIntegral = new FuzzyChoquetIntegral;
-
- if(enableLBSimpleGaussian)
- lbSimpleGaussian = new LBSimpleGaussian;
+ if (enableFuzzyChoquetIntegral)
+ fuzzyChoquetIntegral = new FuzzyChoquetIntegral;
- if(enableLBFuzzyGaussian)
- lbFuzzyGaussian = new LBFuzzyGaussian;
+ if (enableLBSimpleGaussian)
+ lbSimpleGaussian = new LBSimpleGaussian;
- if(enableLBMixtureOfGaussians)
- lbMixtureOfGaussians = new LBMixtureOfGaussians;
+ if (enableLBFuzzyGaussian)
+ lbFuzzyGaussian = new LBFuzzyGaussian;
- if(enableLBAdaptiveSOM)
- lbAdaptiveSOM = new LBAdaptiveSOM;
+ if (enableLBMixtureOfGaussians)
+ lbMixtureOfGaussians = new LBMixtureOfGaussians;
- if(enableLBFuzzyAdaptiveSOM)
- lbFuzzyAdaptiveSOM = new LBFuzzyAdaptiveSOM;
+ if (enableLBAdaptiveSOM)
+ lbAdaptiveSOM = new LBAdaptiveSOM;
- #if !defined(_WIN32)
- if(enableLbpMrf)
- lbpMrf = new LbpMrf;
- #endif
+ if (enableLBFuzzyAdaptiveSOM)
+ lbFuzzyAdaptiveSOM = new LBFuzzyAdaptiveSOM;
- if(enableMultiLayerBGS)
- multiLayerBGS = new MultiLayerBGS;
+#if !defined(_WIN32)
+ if (enableLbpMrf)
+ lbpMrf = new LbpMrf;
+#endif
- //if(enablePBAS)
- // pixelBasedAdaptiveSegmenter = new PixelBasedAdaptiveSegmenter;
+ if(enableMultiLayerBGS)
+ multiLayerBGS = new MultiLayerBGS;
- if(enableVuMeter)
- vuMeter = new VuMeter;
+ //if(enablePBAS)
+ // pixelBasedAdaptiveSegmenter = new PixelBasedAdaptiveSegmenter;
- if(enableKDE)
- kde = new KDE;
+ if (enableVuMeter)
+ vuMeter = new VuMeter;
- if(enableForegroundMaskAnalysis)
- foregroundMaskAnalysis = new ForegroundMaskAnalysis;
-}
+ if (enableKDE)
+ kde = new KDE;
-void FrameProcessor::process(std::string name, IBGS *bgs, const cv::Mat &img_input, cv::Mat &img_bgs)
-{
- if(tictoc == name)
- tic(name);
+ if (enableIMBS)
+ imbs = new IndependentMultimodalBGS;
- cv::Mat img_bkgmodel;
- bgs->process(img_input, img_bgs, img_bkgmodel);
+ if (enableMultiCueBGS)
+ mcbgs = new SJN_MultiCueBGS;
- if(tictoc == name)
- toc();
-}
+ if (enableForegroundMaskAnalysis)
+ foregroundMaskAnalysis = new ForegroundMaskAnalysis;
+ }
-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);
+ void FrameProcessor::process(std::string name, IBGS *bgs, const cv::Mat &img_input, cv::Mat &img_bgs)
+ {
+ if (tictoc == name)
+ tic(name);
-#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
- if(enableGMG)
- process("GMG", gmg, img_prep, img_gmg);
-#endif
+ cv::Mat img_bkgmodel;
+ bgs->process(img_input, img_bgs, img_bkgmodel);
- 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 (tictoc == name)
+ toc();
}
-
- //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(enableForegroundMaskAnalysis)
+
+ void FrameProcessor::process(const cv::Mat &img_input)
{
- 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);
+ 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
- foregroundMaskAnalysis->process(frameNumber, "GMG", img_gmg);
+ if (enableGMG)
+ process("GMG", gmg, img_prep, 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);
- }
- firstTime = false;
-}
+ if (enableDPAdaptiveMedianBGS)
+ process("DPAdaptiveMedianBGS", adaptiveMedian, img_prep, img_adpmed);
-void FrameProcessor::finish(void)
-{
- /*if(enableMultiLayerBGS)
+ 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 (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);
+ }
+
+ firstTime = false;
+ }
+
+ void FrameProcessor::finish(void)
+ {
+ /*if(enableMultiLayerBGS)
multiLayerBGS->finish();
- if(enableLBSimpleGaussian)
+ if(enableLBSimpleGaussian)
lbSimpleGaussian->finish();
-
- if(enableLBFuzzyGaussian)
+
+ if(enableLBFuzzyGaussian)
lbFuzzyGaussian->finish();
- if(enableLBMixtureOfGaussians)
+ if(enableLBMixtureOfGaussians)
lbMixtureOfGaussians->finish();
- if(enableLBAdaptiveSOM)
+ if(enableLBAdaptiveSOM)
lbAdaptiveSOM->finish();
- if(enableLBFuzzyAdaptiveSOM)
+ if(enableLBFuzzyAdaptiveSOM)
lbFuzzyAdaptiveSOM->finish();*/
-
- if(enableForegroundMaskAnalysis)
- delete foregroundMaskAnalysis;
-
- if(enableKDE)
- delete kde;
-
- if(enableVuMeter)
- delete vuMeter;
-
- //if(enablePBAS)
- // delete pixelBasedAdaptiveSegmenter;
- if(enableMultiLayerBGS)
- delete multiLayerBGS;
-
- if(enableLBFuzzyAdaptiveSOM)
- delete lbFuzzyAdaptiveSOM;
+ if (enableForegroundMaskAnalysis)
+ delete foregroundMaskAnalysis;
+
+ if (enableMultiCueBGS)
+ delete mcbgs;
+
+ if (enableIMBS)
+ delete imbs;
+
+ if (enableKDE)
+ delete kde;
- if(enableLBAdaptiveSOM)
- delete lbAdaptiveSOM;
+ if (enableVuMeter)
+ delete vuMeter;
- if(enableLBMixtureOfGaussians)
- delete lbMixtureOfGaussians;
+ //if(enablePBAS)
+ // delete pixelBasedAdaptiveSegmenter;
- if(enableLBFuzzyGaussian)
- delete lbFuzzyGaussian;
+ if (enableMultiLayerBGS)
+ delete multiLayerBGS;
- if(enableLBSimpleGaussian)
- delete lbSimpleGaussian;
+ if (enableLBFuzzyAdaptiveSOM)
+ delete lbFuzzyAdaptiveSOM;
- #if !defined(_WIN32)
- if(enableLbpMrf)
- delete lbpMrf;
- #endif
+ if (enableLBAdaptiveSOM)
+ delete lbAdaptiveSOM;
- if(enableFuzzyChoquetIntegral)
- delete fuzzyChoquetIntegral;
+ if (enableLBMixtureOfGaussians)
+ delete lbMixtureOfGaussians;
- if(enableFuzzySugenoIntegral)
- delete fuzzySugenoIntegral;
+ if (enableLBFuzzyGaussian)
+ delete lbFuzzyGaussian;
+
+ if (enableLBSimpleGaussian)
+ delete lbSimpleGaussian;
+
+#if !defined(_WIN32)
+ if (enableLbpMrf)
+ delete lbpMrf;
+#endif
- if(enableT2FMRF_UV)
- delete type2FuzzyMRF_UV;
+ if(enableFuzzyChoquetIntegral)
+ delete fuzzyChoquetIntegral;
- if(enableT2FMRF_UM)
- delete type2FuzzyMRF_UM;
+ if (enableFuzzySugenoIntegral)
+ delete fuzzySugenoIntegral;
- if(enableT2FGMM_UV)
- delete type2FuzzyGMM_UV;
+ if (enableT2FMRF_UV)
+ delete type2FuzzyMRF_UV;
- if(enableT2FGMM_UM)
- delete type2FuzzyGMM_UM;
+ if (enableT2FMRF_UM)
+ delete type2FuzzyMRF_UM;
- if(enableDPTextureBGS)
- delete textureBGS;
+ if (enableT2FGMM_UV)
+ delete type2FuzzyGMM_UV;
- if(enableDPEigenbackgroundBGS)
- delete eigenBackground;
+ if (enableT2FGMM_UM)
+ delete type2FuzzyGMM_UM;
- if(enableDPPratiMediodBGS)
- delete pratiMediod;
+ if (enableDPTextureBGS)
+ delete textureBGS;
- if(enableDPWrenGABGS)
- delete wrenGA;
+ if (enableDPEigenbackgroundBGS)
+ delete eigenBackground;
- if(enableDPMeanBGS)
- delete temporalMean;
+ if (enableDPPratiMediodBGS)
+ delete pratiMediod;
- if(enableDPZivkovicAGMMBGS)
- delete zivkovicAGMM;
+ if (enableDPWrenGABGS)
+ delete wrenGA;
- if(enableDPGrimsonGMMBGS)
- delete grimsonGMM;
+ if (enableDPMeanBGS)
+ delete temporalMean;
- if(enableDPAdaptiveMedianBGS)
- delete adaptiveMedian;
+ 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;
+ if (enableGMG)
+ delete gmg;
#endif
- if(enableAdaptiveBackgroundLearning)
- delete adaptiveBackgroundLearning;
+ if (enableAdaptiveBackgroundLearning)
+ delete adaptiveBackgroundLearning;
- if(enableMixtureOfGaussianV2BGS)
- delete mixtureOfGaussianV2BGS;
+ if (enableMixtureOfGaussianV2BGS)
+ delete mixtureOfGaussianV2BGS;
- if(enableMixtureOfGaussianV1BGS)
- delete mixtureOfGaussianV1BGS;
+ if (enableMixtureOfGaussianV1BGS)
+ delete mixtureOfGaussianV1BGS;
- if(enableWeightedMovingVarianceBGS)
- delete weightedMovingVariance;
+ if (enableWeightedMovingVarianceBGS)
+ delete weightedMovingVariance;
- if(enableWeightedMovingMeanBGS)
- delete weightedMovingMean;
+ if (enableWeightedMovingMeanBGS)
+ delete weightedMovingMean;
- if(enableStaticFrameDifferenceBGS)
- delete staticFrameDifference;
+ if (enableStaticFrameDifferenceBGS)
+ delete staticFrameDifference;
- if(enableFrameDifferenceBGS)
- delete frameDifference;
+ if (enableFrameDifferenceBGS)
+ delete frameDifference;
- if(enablePreProcessor)
- delete preProcessor;
-}
+ if (enablePreProcessor)
+ delete preProcessor;
+ }
-void FrameProcessor::tic(std::string value)
-{
- processname = value;
- duration = static_cast<double>(cv::getTickCount());
-}
+ 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::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);
+ void FrameProcessor::saveConfig()
+ {
+ CvFileStorage* fs = cvOpenFileStorage("./config/FrameProcessor.xml", 0, CV_STORAGE_WRITE);
+
+ cvWriteString(fs, "tictoc", tictoc.c_str());
- cvWriteString(fs, "tictoc", tictoc.c_str());
+ cvWriteInt(fs, "enablePreProcessor", enablePreProcessor);
- cvWriteInt(fs, "enablePreProcessor", enablePreProcessor);
-
- cvWriteInt(fs, "enableForegroundMaskAnalysis", enableForegroundMaskAnalysis);
+ 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);
+ 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);
+ 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);
-
- 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);
+ 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);
+
+ 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);
+ 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
- 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);
-
- cvReleaseFileStorage(&fs);
+ 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);
+
+ cvReleaseFileStorage(&fs);
+ }
}
diff --git a/FrameProcessor.h b/FrameProcessor.h
index 742b7bdb06cac77e92ac2df8c7b742733cead556..91ce08cbeee3e81fe75d4b7d4a87b78308cdb1cb 100644
--- a/FrameProcessor.h
+++ b/FrameProcessor.h
@@ -66,173 +66,186 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
//#include "package_bgs/pt/PixelBasedAdaptiveSegmenter.h"
#include "package_bgs/av/VuMeter.h"
#include "package_bgs/ae/KDE.h"
+#include "package_bgs/db/IndependentMultimodalBGS.h"
+#include "package_bgs/sjn/SJN_MultiCueBGS.h"
#include "package_analysis/ForegroundMaskAnalysis.h"
-class FrameProcessor : public IFrameProcessor
+namespace bgslibrary
{
-private:
- bool firstTime;
- long frameNumber;
- std::string processname;
- double duration;
- std::string tictoc;
-
- cv::Mat img_prep;
- PreProcessor* preProcessor;
- bool enablePreProcessor;
-
- cv::Mat img_framediff;
- FrameDifferenceBGS* frameDifference;
- bool enableFrameDifferenceBGS;
-
- cv::Mat img_staticfdiff;
- StaticFrameDifferenceBGS* staticFrameDifference;
- bool enableStaticFrameDifferenceBGS;
-
- cv::Mat img_wmovmean;
- WeightedMovingMeanBGS* weightedMovingMean;
- bool enableWeightedMovingMeanBGS;
-
- cv::Mat img_movvar;
- WeightedMovingVarianceBGS* weightedMovingVariance;
- bool enableWeightedMovingVarianceBGS;
-
- cv::Mat img_mog1;
- MixtureOfGaussianV1BGS* mixtureOfGaussianV1BGS;
- bool enableMixtureOfGaussianV1BGS;
-
- cv::Mat img_mog2;
- MixtureOfGaussianV2BGS* mixtureOfGaussianV2BGS;
- bool enableMixtureOfGaussianV2BGS;
-
- cv::Mat img_bkgl_fgmask;
- AdaptiveBackgroundLearning* adaptiveBackgroundLearning;
- bool enableAdaptiveBackgroundLearning;
+ class FrameProcessor : public IFrameProcessor
+ {
+ private:
+ bool firstTime;
+ long frameNumber;
+ std::string processname;
+ double duration;
+ std::string tictoc;
+
+ cv::Mat img_prep;
+ PreProcessor* preProcessor;
+ bool enablePreProcessor;
+
+ cv::Mat img_framediff;
+ FrameDifferenceBGS* frameDifference;
+ bool enableFrameDifferenceBGS;
+
+ cv::Mat img_staticfdiff;
+ StaticFrameDifferenceBGS* staticFrameDifference;
+ bool enableStaticFrameDifferenceBGS;
+
+ cv::Mat img_wmovmean;
+ WeightedMovingMeanBGS* weightedMovingMean;
+ bool enableWeightedMovingMeanBGS;
+
+ cv::Mat img_movvar;
+ WeightedMovingVarianceBGS* weightedMovingVariance;
+ bool enableWeightedMovingVarianceBGS;
+
+ cv::Mat img_mog1;
+ MixtureOfGaussianV1BGS* mixtureOfGaussianV1BGS;
+ bool enableMixtureOfGaussianV1BGS;
+
+ cv::Mat img_mog2;
+ MixtureOfGaussianV2BGS* mixtureOfGaussianV2BGS;
+ bool enableMixtureOfGaussianV2BGS;
+
+ cv::Mat img_bkgl_fgmask;
+ AdaptiveBackgroundLearning* adaptiveBackgroundLearning;
+ bool enableAdaptiveBackgroundLearning;
#if CV_MAJOR_VERSION >= 2 && CV_MINOR_VERSION >= 4 && CV_SUBMINOR_VERSION >= 3
- cv::Mat img_gmg;
- GMG* gmg;
- bool enableGMG;
+ cv::Mat img_gmg;
+ GMG* gmg;
+ bool enableGMG;
#endif
- cv::Mat img_adpmed;
- DPAdaptiveMedianBGS* adaptiveMedian;
- bool enableDPAdaptiveMedianBGS;
-
- cv::Mat img_grigmm;
- DPGrimsonGMMBGS* grimsonGMM;
- bool enableDPGrimsonGMMBGS;
-
- cv::Mat img_zivgmm;
- DPZivkovicAGMMBGS* zivkovicAGMM;
- bool enableDPZivkovicAGMMBGS;
-
- cv::Mat img_tmpmean;
- DPMeanBGS* temporalMean;
- bool enableDPMeanBGS;
-
- cv::Mat img_wrenga;
- DPWrenGABGS* wrenGA;
- bool enableDPWrenGABGS;
-
- cv::Mat img_pramed;
- DPPratiMediodBGS* pratiMediod;
- bool enableDPPratiMediodBGS;
-
- cv::Mat img_eigbkg;
- DPEigenbackgroundBGS* eigenBackground;
- bool enableDPEigenbackgroundBGS;
-
- cv::Mat img_texbgs;
- DPTextureBGS* textureBGS;
- bool enableDPTextureBGS;
-
- cv::Mat img_t2fgmm_um;
- T2FGMM_UM* type2FuzzyGMM_UM;
- bool enableT2FGMM_UM;
-
- cv::Mat img_t2fgmm_uv;
- T2FGMM_UV* type2FuzzyGMM_UV;
- bool enableT2FGMM_UV;
-
- cv::Mat img_t2fmrf_um;
- T2FMRF_UM* type2FuzzyMRF_UM;
- bool enableT2FMRF_UM;
-
- cv::Mat img_t2fmrf_uv;
- T2FMRF_UV* type2FuzzyMRF_UV;
- bool enableT2FMRF_UV;
-
- cv::Mat img_fsi;
- FuzzySugenoIntegral* fuzzySugenoIntegral;
- bool enableFuzzySugenoIntegral;
-
- cv::Mat img_fci;
- FuzzyChoquetIntegral* fuzzyChoquetIntegral;
- bool enableFuzzyChoquetIntegral;
-
- cv::Mat img_lb_sg;
- LBSimpleGaussian* lbSimpleGaussian;
- bool enableLBSimpleGaussian;
-
- cv::Mat img_lb_fg;
- LBFuzzyGaussian* lbFuzzyGaussian;
- bool enableLBFuzzyGaussian;
-
- cv::Mat img_lb_mog;
- LBMixtureOfGaussians* lbMixtureOfGaussians;
- bool enableLBMixtureOfGaussians;
-
- cv::Mat img_lb_som;
- LBAdaptiveSOM* lbAdaptiveSOM;
- bool enableLBAdaptiveSOM;
-
- cv::Mat img_lb_fsom;
- LBFuzzyAdaptiveSOM* lbFuzzyAdaptiveSOM;
- bool enableLBFuzzyAdaptiveSOM;
-
- #if !defined(_WIN32)
- cv::Mat img_lbp_mrf;
- LbpMrf* lbpMrf;
- bool enableLbpMrf;
- #endif
-
- cv::Mat img_mlbgs;
- MultiLayerBGS* multiLayerBGS;
- bool enableMultiLayerBGS;
-
- //cv::Mat img_pt_pbas;
- //PixelBasedAdaptiveSegmenter* pixelBasedAdaptiveSegmenter;
- //bool enablePBAS;
-
- cv::Mat img_vumeter;
- VuMeter* vuMeter;
- bool enableVuMeter;
-
- cv::Mat img_kde;
- KDE* kde;
- bool enableKDE;
-
- ForegroundMaskAnalysis* foregroundMaskAnalysis;
- bool enableForegroundMaskAnalysis;
-
-public:
- FrameProcessor();
- ~FrameProcessor();
-
- long frameToStop;
- std::string imgref;
-
- void init();
- void process(const cv::Mat &img_input);
- void finish(void);
-
-private:
- void process(std::string name, IBGS *bgs, const cv::Mat &img_input, cv::Mat &img_bgs);
- void tic(std::string value);
- void toc();
-
- void saveConfig();
- void loadConfig();
-};
+ cv::Mat img_adpmed;
+ DPAdaptiveMedianBGS* adaptiveMedian;
+ bool enableDPAdaptiveMedianBGS;
+
+ cv::Mat img_grigmm;
+ DPGrimsonGMMBGS* grimsonGMM;
+ bool enableDPGrimsonGMMBGS;
+
+ cv::Mat img_zivgmm;
+ DPZivkovicAGMMBGS* zivkovicAGMM;
+ bool enableDPZivkovicAGMMBGS;
+
+ cv::Mat img_tmpmean;
+ DPMeanBGS* temporalMean;
+ bool enableDPMeanBGS;
+
+ cv::Mat img_wrenga;
+ DPWrenGABGS* wrenGA;
+ bool enableDPWrenGABGS;
+
+ cv::Mat img_pramed;
+ DPPratiMediodBGS* pratiMediod;
+ bool enableDPPratiMediodBGS;
+
+ cv::Mat img_eigbkg;
+ DPEigenbackgroundBGS* eigenBackground;
+ bool enableDPEigenbackgroundBGS;
+
+ cv::Mat img_texbgs;
+ DPTextureBGS* textureBGS;
+ bool enableDPTextureBGS;
+
+ cv::Mat img_t2fgmm_um;
+ T2FGMM_UM* type2FuzzyGMM_UM;
+ bool enableT2FGMM_UM;
+
+ cv::Mat img_t2fgmm_uv;
+ T2FGMM_UV* type2FuzzyGMM_UV;
+ bool enableT2FGMM_UV;
+
+ cv::Mat img_t2fmrf_um;
+ T2FMRF_UM* type2FuzzyMRF_UM;
+ bool enableT2FMRF_UM;
+
+ cv::Mat img_t2fmrf_uv;
+ T2FMRF_UV* type2FuzzyMRF_UV;
+ bool enableT2FMRF_UV;
+
+ cv::Mat img_fsi;
+ FuzzySugenoIntegral* fuzzySugenoIntegral;
+ bool enableFuzzySugenoIntegral;
+
+ cv::Mat img_fci;
+ FuzzyChoquetIntegral* fuzzyChoquetIntegral;
+ bool enableFuzzyChoquetIntegral;
+
+ cv::Mat img_lb_sg;
+ LBSimpleGaussian* lbSimpleGaussian;
+ bool enableLBSimpleGaussian;
+
+ cv::Mat img_lb_fg;
+ LBFuzzyGaussian* lbFuzzyGaussian;
+ bool enableLBFuzzyGaussian;
+
+ cv::Mat img_lb_mog;
+ LBMixtureOfGaussians* lbMixtureOfGaussians;
+ bool enableLBMixtureOfGaussians;
+
+ cv::Mat img_lb_som;
+ LBAdaptiveSOM* lbAdaptiveSOM;
+ bool enableLBAdaptiveSOM;
+
+ cv::Mat img_lb_fsom;
+ LBFuzzyAdaptiveSOM* lbFuzzyAdaptiveSOM;
+ bool enableLBFuzzyAdaptiveSOM;
+
+#if !defined(_WIN32)
+ cv::Mat img_lbp_mrf;
+ LbpMrf* lbpMrf;
+ bool enableLbpMrf;
+#endif
+
+ cv::Mat img_mlbgs;
+ MultiLayerBGS* multiLayerBGS;
+ bool enableMultiLayerBGS;
+
+ //cv::Mat img_pt_pbas;
+ //PixelBasedAdaptiveSegmenter* pixelBasedAdaptiveSegmenter;
+ //bool enablePBAS;
+
+ cv::Mat img_vumeter;
+ VuMeter* vuMeter;
+ bool enableVuMeter;
+
+ cv::Mat img_kde;
+ KDE* kde;
+ bool enableKDE;
+
+ cv::Mat img_imbs;
+ IndependentMultimodalBGS* imbs;
+ bool enableIMBS;
+
+ cv::Mat img_mcbgs;
+ SJN_MultiCueBGS* mcbgs;
+ bool enableMultiCueBGS;
+
+ ForegroundMaskAnalysis* foregroundMaskAnalysis;
+ bool enableForegroundMaskAnalysis;
+
+ public:
+ FrameProcessor();
+ ~FrameProcessor();
+
+ long frameToStop;
+ std::string imgref;
+
+ void init();
+ void process(const cv::Mat &img_input);
+ void finish(void);
+
+ private:
+ void process(std::string name, IBGS *bgs, const cv::Mat &img_input, cv::Mat &img_bgs);
+ void tic(std::string value);
+ void toc();
+
+ void saveConfig();
+ void loadConfig();
+ };
+}
diff --git a/IFrameProcessor.h b/IFrameProcessor.h
index ef50b1ff9d5b44effdc3d2f44c138417ac83205f..b3a44411ecc1c73011a1664370a593acfb3550d8 100644
--- a/IFrameProcessor.h
+++ b/IFrameProcessor.h
@@ -18,9 +18,12 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
#include <cv.h>
-class IFrameProcessor
+namespace bgslibrary
{
+ class IFrameProcessor
+ {
public:
- virtual void process(const cv:: Mat &input) = 0;
- virtual ~IFrameProcessor(){}
-};
\ No newline at end of file
+ virtual void process(const cv::Mat &input) = 0;
+ virtual ~IFrameProcessor(){}
+ };
+}
diff --git a/Main.cpp b/Main.cpp
index 4e59ee5b2d9d644b8f6989fbf030d9b0f0748e15..3d27e61e7b4d76dfc41fe1cb941854b056e079a0 100644
--- a/Main.cpp
+++ b/Main.cpp
@@ -18,65 +18,68 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
#include "VideoAnalysis.h"
#include <iostream>
-class Main
+namespace bgslibrary
{
-private:
- Main();
-
-public:
- static void start(int argc, const char **argv)
+ class Main
{
- std::cout << "-----------------------------------------" << std::endl;
- std::cout << "Background Subtraction Library v1.7.0 " << std::endl;
- std::cout << "http://code.google.com/p/bgslibrary " << std::endl;
- std::cout << "by: " << std::endl;
- std::cout << "Andrews Sobral (andrewssobral@gmail.com) " << std::endl;
- std::cout << "-----------------------------------------" << std::endl;
- std::cout << "Using OpenCV version " << CV_VERSION << std::endl;
-
- try
+ private:
+ Main();
+
+ public:
+ static void start(int argc, const char **argv)
{
- int key = KEY_ESC;
+ std::cout << "-----------------------------------------" << std::endl;
+ std::cout << "Background Subtraction Library v1.9.0 " << std::endl;
+ std::cout << "http://code.google.com/p/bgslibrary " << std::endl;
+ std::cout << "by: " << std::endl;
+ std::cout << "Andrews Sobral (andrewssobral@gmail.com) " << std::endl;
+ std::cout << "-----------------------------------------" << std::endl;
+ std::cout << "Using OpenCV version " << CV_VERSION << std::endl;
- do
+ try
{
- VideoAnalysis* videoAnalysis = new VideoAnalysis;
+ int key = KEY_ESC;
- if(videoAnalysis->setup(argc, argv))
+ do
{
- videoAnalysis->start();
+ VideoAnalysis* videoAnalysis = new VideoAnalysis;
- std::cout << "Processing finished, enter:" << std::endl;
- std::cout << "R - Repeat" << std::endl;
- std::cout << "Q - Quit" << std::endl;
+ if (videoAnalysis->setup(argc, argv))
+ {
+ videoAnalysis->start();
- key = cv::waitKey();
- }
+ std::cout << "Processing finished, enter:" << std::endl;
+ std::cout << "R - Repeat" << std::endl;
+ std::cout << "Q - Quit" << std::endl;
- cv::destroyAllWindows();
- delete videoAnalysis;
+ key = cv::waitKey();
+ }
- }while(key == KEY_REPEAT);
- }
- catch(const std::exception& ex)
- {
- std::cout << "std::exception:" << ex.what() << std::endl;
- return;
- }
- catch(...)
- {
- std::cout << "Unknow error" << std::endl;
- return;
- }
+ cv::destroyAllWindows();
+ delete videoAnalysis;
+
+ } while (key == KEY_REPEAT);
+ }
+ catch (const std::exception& ex)
+ {
+ std::cout << "std::exception:" << ex.what() << std::endl;
+ return;
+ }
+ catch (...)
+ {
+ std::cout << "Unknow error" << std::endl;
+ return;
+ }
#ifdef WIN32
- //system("pause");
+ //system("pause");
#endif
- }
-};
+ }
+ };
+}
int main(int argc, const char **argv)
{
- Main::start(argc, argv);
+ bgslibrary::Main::start(argc, argv);
return 0;
}
diff --git a/PreProcessor.cpp b/PreProcessor.cpp
index 834996bb82d44e9498edf4a4ec7b7c54afdcedd3..6f4ebbe964c197f35c21654d6eeb15e85337a40a 100644
--- a/PreProcessor.cpp
+++ b/PreProcessor.cpp
@@ -16,131 +16,134 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
*/
#include "PreProcessor.h"
-PreProcessor::PreProcessor() : firstTime(true), equalizeHist(false), gaussianBlur(false)
+namespace bgslibrary
{
- std::cout << "PreProcessor()" << std::endl;
-}
-
-PreProcessor::~PreProcessor()
-{
- std::cout << "~PreProcessor()" << std::endl;
-}
+ PreProcessor::PreProcessor() : firstTime(true), equalizeHist(false), gaussianBlur(false)
+ {
+ std::cout << "PreProcessor()" << std::endl;
+ }
+
+ PreProcessor::~PreProcessor()
+ {
+ std::cout << "~PreProcessor()" << std::endl;
+ }
+
+ void PreProcessor::setEqualizeHist(bool value)
+ {
+ equalizeHist = value;
+ }
+
+ void PreProcessor::setGaussianBlur(bool value)
+ {
+ gaussianBlur = value;
+ }
+
+ cv::Mat PreProcessor::getGrayScale()
+ {
+ return img_gray.clone();
+ }
+
+ void PreProcessor::process(const cv::Mat &img_input, cv::Mat &img_output)
+ {
+ if (img_input.empty())
+ return;
+
+ loadConfig();
+
+ if (firstTime)
+ saveConfig();
+
+ img_input.copyTo(img_output);
+
+ // Converts image from one color space to another
+ // http://opencv.willowgarage.com/documentation/cpp/miscellaneous_image_transformations.html#cv-cvtcolor
+ cv::cvtColor(img_input, img_gray, CV_BGR2GRAY);
+ //img_gray.copyTo(img_output);
+
+ // Equalizes the histogram of a grayscale image
+ // http://opencv.willowgarage.com/documentation/cpp/histograms.html#cv-equalizehist
+ if (equalizeHist)
+ cv::equalizeHist(img_output, img_output);
+
+ // Smoothes image using a Gaussian filter
+ // http://opencv.willowgarage.com/documentation/cpp/imgproc_image_filtering.html#GaussianBlur
+ if (gaussianBlur)
+ cv::GaussianBlur(img_output, img_output, cv::Size(7, 7), 1.5);
+
+ if (enableShow)
+ cv::imshow("Pre Processor", img_output);
+
+ firstTime = false;
+ }
+
+ void PreProcessor::rotate(const cv::Mat &img_input, cv::Mat &img_output, float angle)
+ {
+ IplImage* image = new IplImage(img_input);
+
+ //IplImage *rotatedImage = cvCreateImage(cvSize(480,320), IPL_DEPTH_8U, image->nChannels);
+ //IplImage *rotatedImage = cvCreateImage(cvSize(image->width,image->height), IPL_DEPTH_8U, image->nChannels);
+ IplImage* rotatedImage = cvCreateImage(cvSize(image->height, image->width), IPL_DEPTH_8U, image->nChannels);
+
+ CvPoint2D32f center;
+ //center.x = 160;
+ //center.y = 160;
+ center.x = (image->height / 2);
+ center.y = (image->width / 2);
+
+ CvMat* mapMatrix = cvCreateMat(2, 3, CV_32FC1);
+
+ cv2DRotationMatrix(center, angle, 1.0, mapMatrix);
+ cvWarpAffine(image, rotatedImage, mapMatrix, CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS, cvScalarAll(0));
+
+ cv::Mat img_rot(rotatedImage);
+ img_rot.copyTo(img_output);
+
+ cvReleaseImage(&image);
+ cvReleaseImage(&rotatedImage);
+ cvReleaseMat(&mapMatrix);
+ }
+
+ void PreProcessor::applyCanny(const cv::Mat &img_input, cv::Mat &img_output)
+ {
+ if (img_input.empty())
+ return;
+
+ //------------------------------------------------------------------
+ // Canny
+ // Finds edges in an image using Canny algorithm.
+ // http://opencv.willowgarage.com/documentation/cpp/imgproc_feature_detection.html#cv-canny
+ //------------------------------------------------------------------
+
+ cv::Mat img_canny;
+ cv::Canny(
+ img_input, // image � Single-channel 8-bit input image
+ img_canny, // edges � The output edge map. It will have the same size and the same type as image
+ 100, // threshold1 � The first threshold for the hysteresis procedure
+ 200); // threshold2 � The second threshold for the hysteresis procedure
+ cv::threshold(img_canny, img_canny, 128, 255, cv::THRESH_BINARY_INV);
+
+ img_canny.copyTo(img_output);
+ }
+
+ void PreProcessor::saveConfig()
+ {
+ CvFileStorage* fs = cvOpenFileStorage("./config/PreProcessor.xml", 0, CV_STORAGE_WRITE);
+
+ cvWriteInt(fs, "equalizeHist", equalizeHist);
+ cvWriteInt(fs, "gaussianBlur", gaussianBlur);
+ cvWriteInt(fs, "enableShow", enableShow);
-void PreProcessor::setEqualizeHist(bool value)
-{
- equalizeHist = value;
-}
+ cvReleaseFileStorage(&fs);
+ }
-void PreProcessor::setGaussianBlur(bool value)
-{
- gaussianBlur = value;
-}
+ void PreProcessor::loadConfig()
+ {
+ CvFileStorage* fs = cvOpenFileStorage("./config/PreProcessor.xml", 0, CV_STORAGE_READ);
-cv::Mat PreProcessor::getGrayScale()
-{
- return img_gray.clone();
-}
+ equalizeHist = cvReadIntByName(fs, 0, "equalizeHist", false);
+ gaussianBlur = cvReadIntByName(fs, 0, "gaussianBlur", false);
+ enableShow = cvReadIntByName(fs, 0, "enableShow", true);
-void PreProcessor::process(const cv::Mat &img_input, cv::Mat &img_output)
-{
- if(img_input.empty())
- return;
-
- loadConfig();
-
- if(firstTime)
- saveConfig();
-
- img_input.copyTo(img_output);
-
- // Converts image from one color space to another
- // http://opencv.willowgarage.com/documentation/cpp/miscellaneous_image_transformations.html#cv-cvtcolor
- cv::cvtColor(img_input, img_gray, CV_BGR2GRAY);
- //img_gray.copyTo(img_output);
-
- // Equalizes the histogram of a grayscale image
- // http://opencv.willowgarage.com/documentation/cpp/histograms.html#cv-equalizehist
- if(equalizeHist)
- cv::equalizeHist(img_output, img_output);
-
- // Smoothes image using a Gaussian filter
- // http://opencv.willowgarage.com/documentation/cpp/imgproc_image_filtering.html#GaussianBlur
- if(gaussianBlur)
- cv::GaussianBlur(img_output, img_output, cv::Size(7,7), 1.5);
-
- if(enableShow)
- cv::imshow("Pre Processor", img_output);
-
- firstTime = false;
+ cvReleaseFileStorage(&fs);
+ }
}
-
-void PreProcessor::rotate(const cv::Mat &img_input, cv::Mat &img_output, float angle)
-{
- IplImage* image = new IplImage(img_input);
-
- //IplImage *rotatedImage = cvCreateImage(cvSize(480,320), IPL_DEPTH_8U, image->nChannels);
- //IplImage *rotatedImage = cvCreateImage(cvSize(image->width,image->height), IPL_DEPTH_8U, image->nChannels);
- IplImage* rotatedImage = cvCreateImage(cvSize(image->height,image->width), IPL_DEPTH_8U, image->nChannels);
-
- CvPoint2D32f center;
- //center.x = 160;
- //center.y = 160;
- center.x = (image->height / 2);
- center.y = (image->width / 2);
-
- CvMat* mapMatrix = cvCreateMat(2, 3, CV_32FC1);
-
- cv2DRotationMatrix(center, angle, 1.0, mapMatrix);
- cvWarpAffine(image, rotatedImage, mapMatrix, CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS, cvScalarAll(0));
-
- cv::Mat img_rot(rotatedImage);
- img_rot.copyTo(img_output);
-
- cvReleaseImage(&image);
- cvReleaseImage(&rotatedImage);
- cvReleaseMat(&mapMatrix);
-}
-
-void PreProcessor::applyCanny(const cv::Mat &img_input, cv::Mat &img_output)
-{
- if(img_input.empty())
- return;
-
- //------------------------------------------------------------------
- // Canny
- // Finds edges in an image using Canny algorithm.
- // http://opencv.willowgarage.com/documentation/cpp/imgproc_feature_detection.html#cv-canny
- //------------------------------------------------------------------
-
- cv::Mat img_canny;
- cv::Canny(
- img_input, // image � Single-channel 8-bit input image
- img_canny, // edges � The output edge map. It will have the same size and the same type as image
- 100, // threshold1 � The first threshold for the hysteresis procedure
- 200); // threshold2 � The second threshold for the hysteresis procedure
- cv::threshold(img_canny, img_canny, 128, 255, cv::THRESH_BINARY_INV);
-
- img_canny.copyTo(img_output);
-}
-
-void PreProcessor::saveConfig()
-{
- CvFileStorage* fs = cvOpenFileStorage("./config/PreProcessor.xml", 0, CV_STORAGE_WRITE);
-
- cvWriteInt(fs, "equalizeHist", equalizeHist);
- cvWriteInt(fs, "gaussianBlur", gaussianBlur);
- cvWriteInt(fs, "enableShow", enableShow);
-
- cvReleaseFileStorage(&fs);
-}
-
-void PreProcessor::loadConfig()
-{
- CvFileStorage* fs = cvOpenFileStorage("./config/PreProcessor.xml", 0, CV_STORAGE_READ);
-
- equalizeHist = cvReadIntByName(fs, 0, "equalizeHist", false);
- gaussianBlur = cvReadIntByName(fs, 0, "gaussianBlur", false);
- enableShow = cvReadIntByName(fs, 0, "enableShow", true);
-
- cvReleaseFileStorage(&fs);
-}
\ No newline at end of file
diff --git a/PreProcessor.h b/PreProcessor.h
index 9a0462366ec4821a1a803050619ccd3f0189b2ed..e00100369cfbf49d480481bab173683f93f9e5fe 100644
--- a/PreProcessor.h
+++ b/PreProcessor.h
@@ -20,30 +20,32 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
#include <cv.h>
#include <highgui.h>
-class PreProcessor
+namespace bgslibrary
{
-private:
- bool firstTime;
- bool equalizeHist;
- bool gaussianBlur;
- cv::Mat img_gray;
- bool enableShow;
-
-public:
- PreProcessor();
- ~PreProcessor();
-
- void setEqualizeHist(bool value);
- void setGaussianBlur(bool value);
- cv::Mat getGrayScale();
-
- void process(const cv::Mat &img_input, cv::Mat &img_output);
-
- void rotate(const cv::Mat &img_input, cv::Mat &img_output, float angle);
- void applyCanny(const cv::Mat &img_input, cv::Mat &img_output);
-
-private:
- void saveConfig();
- void loadConfig();
-};
-
+ class PreProcessor
+ {
+ private:
+ bool firstTime;
+ bool equalizeHist;
+ bool gaussianBlur;
+ cv::Mat img_gray;
+ bool enableShow;
+
+ public:
+ PreProcessor();
+ ~PreProcessor();
+
+ void setEqualizeHist(bool value);
+ void setGaussianBlur(bool value);
+ cv::Mat getGrayScale();
+
+ void process(const cv::Mat &img_input, cv::Mat &img_output);
+
+ void rotate(const cv::Mat &img_input, cv::Mat &img_output, float angle);
+ void applyCanny(const cv::Mat &img_input, cv::Mat &img_output);
+
+ private:
+ void saveConfig();
+ void loadConfig();
+ };
+}
diff --git a/VideoAnalysis.cpp b/VideoAnalysis.cpp
index 0123933b9f29b21ce42f6142a7ebda87ff7f9de3..604b3ceb10c66407d10be4e160f9f539f9b9e270 100644
--- a/VideoAnalysis.cpp
+++ b/VideoAnalysis.cpp
@@ -16,115 +16,118 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
*/
#include "VideoAnalysis.h"
-VideoAnalysis::VideoAnalysis() : use_file(false), use_camera(false), cameraIndex(0), use_comp(false), frameToStop(0)
+namespace bgslibrary
{
- std::cout << "VideoAnalysis()" << std::endl;
-}
-
-VideoAnalysis::~VideoAnalysis()
-{
- std::cout << "~VideoAnalysis()" << std::endl;
-}
-
-bool VideoAnalysis::setup(int argc, const char **argv)
-{
- bool flag = false;
-
- const char* keys =
- "{hp|help|false|Print help message}"
- "{uf|use_file|false|Use video file}"
- "{fn|filename||Specify video file}"
- "{uc|use_cam|false|Use camera}"
- "{ca|camera|0|Specify camera index}"
- "{co|use_comp|false|Use mask comparator}"
- "{st|stopAt|0|Frame number to stop}"
- "{im|imgref||Specify image file}"
- ;
- cv::CommandLineParser cmd(argc, argv, keys);
-
- if(argc <= 1 || cmd.get<bool>("help") == true)
+ VideoAnalysis::VideoAnalysis() : use_file(false), use_camera(false), cameraIndex(0), use_comp(false), frameToStop(0)
{
- std::cout << "Usage: " << argv[0] << " [options]" << std::endl;
- std::cout << "Avaible options:" << std::endl;
- cmd.printParams();
- return false;
+ std::cout << "VideoAnalysis()" << std::endl;
}
- use_file = cmd.get<bool>("use_file");
- if(use_file)
+ VideoAnalysis::~VideoAnalysis()
{
- filename = cmd.get<std::string>("filename");
+ std::cout << "~VideoAnalysis()" << std::endl;
+ }
- if(filename.empty())
+ bool VideoAnalysis::setup(int argc, const char **argv)
+ {
+ bool flag = false;
+
+ const char* keys =
+ "{hp|help|false|Print help message}"
+ "{uf|use_file|false|Use video file}"
+ "{fn|filename||Specify video file}"
+ "{uc|use_cam|false|Use camera}"
+ "{ca|camera|0|Specify camera index}"
+ "{co|use_comp|false|Use mask comparator}"
+ "{st|stopAt|0|Frame number to stop}"
+ "{im|imgref||Specify image file}"
+ ;
+ cv::CommandLineParser cmd(argc, argv, keys);
+
+ if (argc <= 1 || cmd.get<bool>("help") == true)
{
- std::cout << "Specify filename"<< std::endl;
+ std::cout << "Usage: " << argv[0] << " [options]" << std::endl;
+ std::cout << "Avaible options:" << std::endl;
+ cmd.printParams();
return false;
}
-
- flag = true;
- }
- use_camera = cmd.get<bool>("use_cam");
- if(use_camera)
- {
- cameraIndex = cmd.get<int>("camera");
- flag = true;
- }
-
- if(flag == true)
- {
- use_comp = cmd.get<bool>("use_comp");
- if(use_comp)
+ use_file = cmd.get<bool>("use_file");
+ if (use_file)
{
- frameToStop = cmd.get<int>("stopAt");
- imgref = cmd.get<std::string>("imgref");
+ filename = cmd.get<std::string>("filename");
- if(imgref.empty())
+ if (filename.empty())
{
- std::cout << "Specify image reference"<< std::endl;
+ std::cout << "Specify filename" << std::endl;
return false;
}
+
+ flag = true;
}
- }
- return flag;
-}
+ use_camera = cmd.get<bool>("use_cam");
+ if (use_camera)
+ {
+ cameraIndex = cmd.get<int>("camera");
+ flag = true;
+ }
-void VideoAnalysis::start()
-{
- do
+ if (flag == true)
+ {
+ use_comp = cmd.get<bool>("use_comp");
+ if (use_comp)
+ {
+ frameToStop = cmd.get<int>("stopAt");
+ imgref = cmd.get<std::string>("imgref");
+
+ if (imgref.empty())
+ {
+ std::cout << "Specify image reference" << std::endl;
+ return false;
+ }
+ }
+ }
+
+ return flag;
+ }
+
+ void VideoAnalysis::start()
{
- videoCapture = new VideoCapture;
- frameProcessor = new FrameProcessor;
+ do
+ {
+ videoCapture = new VideoCapture;
+ frameProcessor = new FrameProcessor;
+
+ frameProcessor->init();
+ frameProcessor->frameToStop = frameToStop;
+ frameProcessor->imgref = imgref;
+
+ videoCapture->setFrameProcessor(frameProcessor);
+
+ if (use_file)
+ videoCapture->setVideo(filename);
- frameProcessor->init();
- frameProcessor->frameToStop = frameToStop;
- frameProcessor->imgref = imgref;
+ if (use_camera)
+ videoCapture->setCamera(cameraIndex);
- videoCapture->setFrameProcessor(frameProcessor);
+ videoCapture->start();
- if(use_file)
- videoCapture->setVideo(filename);
-
- if(use_camera)
- videoCapture->setCamera(cameraIndex);
-
- videoCapture->start();
+ if (use_file || use_camera)
+ break;
- if(use_file || use_camera)
- break;
+ frameProcessor->finish();
- frameProcessor->finish();
+ int key = cvWaitKey(500);
+ if (key == KEY_ESC)
+ break;
- int key = cvWaitKey(500);
- if(key == KEY_ESC)
- break;
+ delete frameProcessor;
+ delete videoCapture;
+
+ } while (1);
delete frameProcessor;
delete videoCapture;
-
- }while(1);
-
- delete frameProcessor;
- delete videoCapture;
-}
\ No newline at end of file
+ }
+}
diff --git a/VideoAnalysis.h b/VideoAnalysis.h
index 74eacf764cc8a49655c23b897ca7b73f76eef4e9..f548a7bfcb50f981780825034dc2a324de077ae2 100644
--- a/VideoAnalysis.h
+++ b/VideoAnalysis.h
@@ -22,24 +22,26 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
#include "VideoCapture.h"
#include "FrameProcessor.h"
-class VideoAnalysis
+namespace bgslibrary
{
-private:
- VideoCapture* videoCapture;
- FrameProcessor* frameProcessor;
- bool use_file;
- std::string filename;
- bool use_camera;
- int cameraIndex;
- bool use_comp;
- long frameToStop;
- std::string imgref;
-
-public:
- VideoAnalysis();
- ~VideoAnalysis();
-
- bool setup(int argc, const char **argv);
- void start();
-};
-
+ class VideoAnalysis
+ {
+ private:
+ VideoCapture* videoCapture;
+ FrameProcessor* frameProcessor;
+ bool use_file;
+ std::string filename;
+ bool use_camera;
+ int cameraIndex;
+ bool use_comp;
+ long frameToStop;
+ std::string imgref;
+
+ public:
+ VideoAnalysis();
+ ~VideoAnalysis();
+
+ bool setup(int argc, const char **argv);
+ void start();
+ };
+}
diff --git a/VideoCapture.cpp b/VideoCapture.cpp
index 895205376a3474c7b03a5e21de923b1352c62332..401fb2729f64bb5d6d376910c186ca6e3f52b7e4 100644
--- a/VideoCapture.cpp
+++ b/VideoCapture.cpp
@@ -16,260 +16,263 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
*/
#include "VideoCapture.h"
-namespace VC_ROI
+namespace bgslibrary
{
- IplImage* img_input1 = 0;
- IplImage* img_input2 = 0;
- int roi_x0 = 0;
- int roi_y0 = 0;
- int roi_x1 = 0;
- int roi_y1 = 0;
- int numOfRec = 0;
- int startDraw = 0;
- bool roi_defined = false;
- bool use_roi = true;
- bool disable_event = false;
-
- void reset(void)
+ namespace VC_ROI
{
- disable_event = false;
- startDraw = false;
- }
+ IplImage* img_input1 = 0;
+ IplImage* img_input2 = 0;
+ int roi_x0 = 0;
+ int roi_y0 = 0;
+ int roi_x1 = 0;
+ int roi_y1 = 0;
+ int numOfRec = 0;
+ int startDraw = 0;
+ bool roi_defined = false;
+ bool use_roi = true;
+ bool disable_event = false;
+
+ void reset(void)
+ {
+ disable_event = false;
+ startDraw = false;
+ }
- void VideoCapture_on_mouse(int evt, int x, int y, int flag, void* param)
- {
- if(use_roi == false || disable_event == true)
- return;
-
- if(evt == CV_EVENT_LBUTTONDOWN)
+ void VideoCapture_on_mouse(int evt, int x, int y, int flag, void* param)
{
- if(!startDraw)
+ if (use_roi == false || disable_event == true)
+ return;
+
+ if (evt == CV_EVENT_LBUTTONDOWN)
{
- roi_x0 = x;
- roi_y0 = y;
- startDraw = 1;
+ if (!startDraw)
+ {
+ roi_x0 = x;
+ roi_y0 = y;
+ startDraw = 1;
+ }
+ else
+ {
+ roi_x1 = x;
+ roi_y1 = y;
+ startDraw = 0;
+ roi_defined = true;
+ disable_event = true;
+ }
}
- else
+
+ if (evt == CV_EVENT_MOUSEMOVE && startDraw)
{
- roi_x1 = x;
- roi_y1 = y;
- startDraw = 0;
- roi_defined = true;
- disable_event = true;
+ //redraw ROI selection
+ img_input2 = cvCloneImage(img_input1);
+ cvRectangle(img_input2, cvPoint(roi_x0, roi_y0), cvPoint(x, y), CV_RGB(255, 0, 0), 1);
+ cvShowImage("Input", img_input2);
+ cvReleaseImage(&img_input2);
+ //startDraw = false;
+ //disable_event = true;
}
}
-
- if(evt == CV_EVENT_MOUSEMOVE && startDraw)
- {
- //redraw ROI selection
- img_input2 = cvCloneImage(img_input1);
- cvRectangle(img_input2, cvPoint(roi_x0,roi_y0), cvPoint(x,y), CV_RGB(255,0,0), 1);
- cvShowImage("Input", img_input2);
- cvReleaseImage(&img_input2);
- //startDraw = false;
- //disable_event = true;
- }
}
-}
-VideoCapture::VideoCapture() : key(0), start_time(0), delta_time(0), freq(0), fps(0), frameNumber(0), stopAt(0),
- useCamera(false), useVideo(false), input_resize_percent(100), showOutput(true), enableFlip(false)
-{
- std::cout << "VideoCapture()" << std::endl;
-}
+ VideoCapture::VideoCapture() : key(0), start_time(0), delta_time(0), freq(0), fps(0), frameNumber(0), stopAt(0),
+ useCamera(false), useVideo(false), input_resize_percent(100), showOutput(true), enableFlip(false)
+ {
+ std::cout << "VideoCapture()" << std::endl;
+ }
-VideoCapture::~VideoCapture()
-{
- std::cout << "~VideoCapture()" << std::endl;
-}
+ VideoCapture::~VideoCapture()
+ {
+ std::cout << "~VideoCapture()" << std::endl;
+ }
-void VideoCapture::setFrameProcessor(IFrameProcessor* frameProcessorPtr)
-{
- frameProcessor = frameProcessorPtr;
-}
+ void VideoCapture::setFrameProcessor(IFrameProcessor* frameProcessorPtr)
+ {
+ frameProcessor = frameProcessorPtr;
+ }
-void VideoCapture::setCamera(int index)
-{
- useCamera = true;
- cameraIndex = index;
+ void VideoCapture::setCamera(int index)
+ {
+ useCamera = true;
+ cameraIndex = index;
- useVideo = false;
-}
+ useVideo = false;
+ }
-void VideoCapture::setUpCamera()
-{
- std::cout << "Camera index:" << cameraIndex << std::endl;
- capture = cvCaptureFromCAM(cameraIndex);
+ void VideoCapture::setUpCamera()
+ {
+ std::cout << "Camera index:" << cameraIndex << std::endl;
+ capture = cvCaptureFromCAM(cameraIndex);
- if(!capture)
- std::cerr << "Cannot open initialize webcam!\n" << std::endl;
-}
+ if (!capture)
+ std::cerr << "Cannot open initialize webcam!\n" << std::endl;
+ }
-void VideoCapture::setVideo(std::string filename)
-{
- useVideo = true;
- videoFileName = filename;
+ void VideoCapture::setVideo(std::string filename)
+ {
+ useVideo = true;
+ videoFileName = filename;
- useCamera = false;
-}
+ useCamera = false;
+ }
-void VideoCapture::setUpVideo()
-{
- capture = cvCaptureFromFile(videoFileName.c_str());
+ void VideoCapture::setUpVideo()
+ {
+ capture = cvCaptureFromFile(videoFileName.c_str());
- if(!capture)
- std::cerr << "Cannot open video file "<< videoFileName << std::endl;
-}
+ if (!capture)
+ std::cerr << "Cannot open video file " << videoFileName << std::endl;
+ }
-void VideoCapture::start()
-{
- loadConfig();
-
- if(useCamera) setUpCamera();
- if(useVideo) setUpVideo();
- if(!capture) std::cerr << "Capture error..." << std::endl;
-
- int input_fps = cvGetCaptureProperty(capture,CV_CAP_PROP_FPS);
- std::cout << "input->fps:" << input_fps << std::endl;
-
- IplImage* frame1 = cvQueryFrame(capture);
- frame = cvCreateImage(cvSize((int)((frame1->width*input_resize_percent)/100) , (int)((frame1->height*input_resize_percent)/100)), frame1->depth, frame1->nChannels);
- //cvCreateImage(cvSize(frame1->width/input_resize_factor, frame1->height/input_resize_factor), frame1->depth, frame1->nChannels);
- std::cout << "input->resize_percent:" << input_resize_percent << std::endl;
- std::cout << "input->width:" << frame->width << std::endl;
- std::cout << "input->height:" << frame->height << std::endl;
-
- double loopDelay = 33.333;
- if(input_fps > 0)
- loopDelay = (1./input_fps)*1000.;
- std::cout << "loopDelay:" << loopDelay << std::endl;
-
- bool firstTime = true;
- do
+ void VideoCapture::start()
{
- frameNumber++;
+ loadConfig();
+
+ if (useCamera) setUpCamera();
+ if (useVideo) setUpVideo();
+ if (!capture) std::cerr << "Capture error..." << std::endl;
- frame1 = cvQueryFrame(capture);
- if(!frame1) break;
+ int input_fps = cvGetCaptureProperty(capture, CV_CAP_PROP_FPS);
+ std::cout << "input->fps:" << input_fps << std::endl;
- cvResize(frame1, frame);
+ IplImage* frame1 = cvQueryFrame(capture);
+ frame = cvCreateImage(cvSize((int)((frame1->width*input_resize_percent) / 100), (int)((frame1->height*input_resize_percent) / 100)), frame1->depth, frame1->nChannels);
+ //cvCreateImage(cvSize(frame1->width/input_resize_factor, frame1->height/input_resize_factor), frame1->depth, frame1->nChannels);
+ std::cout << "input->resize_percent:" << input_resize_percent << std::endl;
+ std::cout << "input->width:" << frame->width << std::endl;
+ std::cout << "input->height:" << frame->height << std::endl;
- if(enableFlip)
- cvFlip(frame, frame, 0);
-
- if(VC_ROI::use_roi == true && VC_ROI::roi_defined == false && firstTime == true)
+ double loopDelay = 33.333;
+ if (input_fps > 0)
+ loopDelay = (1. / input_fps)*1000.;
+ std::cout << "loopDelay:" << loopDelay << std::endl;
+
+ bool firstTime = true;
+ do
{
- VC_ROI::reset();
+ frameNumber++;
- do
- {
- cv::Mat img_input(frame);
-
- if(showOutput)
- {
- cv::imshow("Input", img_input);
+ frame1 = cvQueryFrame(capture);
+ if (!frame1) break;
- std::cout << "Set ROI (press ESC to skip)" << std::endl;
- VC_ROI::img_input1 = new IplImage(img_input);
- cvSetMouseCallback("Input", VC_ROI::VideoCapture_on_mouse, NULL);
- key = cvWaitKey(0);
- delete VC_ROI::img_input1;
- }
- else
- key = KEY_ESC;
+ cvResize(frame1, frame);
- if(key == KEY_ESC)
- {
- std::cout << "ROI disabled" << std::endl;
- VC_ROI::reset();
- VC_ROI::use_roi = false;
- break;
- }
+ if (enableFlip)
+ cvFlip(frame, frame, 0);
+
+ if (VC_ROI::use_roi == true && VC_ROI::roi_defined == false && firstTime == true)
+ {
+ VC_ROI::reset();
- if(VC_ROI::roi_defined)
+ do
{
- std::cout << "ROI defined (" << VC_ROI::roi_x0 << "," << VC_ROI::roi_y0 << "," << VC_ROI::roi_x1 << "," << VC_ROI::roi_y1 << ")" << std::endl;
- break;
- }
- else
- std::cout << "ROI undefined" << std::endl;
+ cv::Mat img_input(frame);
+
+ if (showOutput)
+ {
+ cv::imshow("Input", img_input);
+
+ std::cout << "Set ROI (press ESC to skip)" << std::endl;
+ VC_ROI::img_input1 = new IplImage(img_input);
+ cvSetMouseCallback("Input", VC_ROI::VideoCapture_on_mouse, NULL);
+ key = cvWaitKey(0);
+ delete VC_ROI::img_input1;
+ }
+ else
+ key = KEY_ESC;
+
+ if (key == KEY_ESC)
+ {
+ std::cout << "ROI disabled" << std::endl;
+ VC_ROI::reset();
+ VC_ROI::use_roi = false;
+ break;
+ }
+
+ if (VC_ROI::roi_defined)
+ {
+ std::cout << "ROI defined (" << VC_ROI::roi_x0 << "," << VC_ROI::roi_y0 << "," << VC_ROI::roi_x1 << "," << VC_ROI::roi_y1 << ")" << std::endl;
+ break;
+ }
+ else
+ std::cout << "ROI undefined" << std::endl;
+
+ } while (1);
+ }
- }while(1);
- }
+ if (VC_ROI::use_roi == true && VC_ROI::roi_defined == true)
+ {
+ CvRect rect = cvRect(VC_ROI::roi_x0, VC_ROI::roi_y0, VC_ROI::roi_x1 - VC_ROI::roi_x0, VC_ROI::roi_y1 - VC_ROI::roi_y0);
+ cvSetImageROI(frame, rect);
+ }
- if(VC_ROI::use_roi == true && VC_ROI::roi_defined == true)
- {
- CvRect rect = cvRect(VC_ROI::roi_x0, VC_ROI::roi_y0, VC_ROI::roi_x1 - VC_ROI::roi_x0, VC_ROI::roi_y1 - VC_ROI::roi_y0);
- cvSetImageROI(frame, rect);
- }
+ cv::Mat img_input(frame);
- cv::Mat img_input(frame);
-
- if(showOutput)
- cv::imshow("Input", img_input);
+ if (showOutput)
+ cv::imshow("Input", img_input);
- if(firstTime)
- saveConfig();
+ if (firstTime)
+ saveConfig();
- start_time = cv::getTickCount();
- frameProcessor->process(img_input);
- int64 delta_time = cv::getTickCount() - start_time;
- freq = cv::getTickFrequency();
- fps = freq / delta_time;
- //std::cout << "FPS: " << fps << std::endl;
+ start_time = cv::getTickCount();
+ frameProcessor->process(img_input);
+ int64 delta_time = cv::getTickCount() - start_time;
+ freq = cv::getTickFrequency();
+ fps = freq / delta_time;
+ //std::cout << "FPS: " << fps << std::endl;
- cvResetImageROI(frame);
+ cvResetImageROI(frame);
- key = cvWaitKey(loopDelay);
- //std::cout << "key: " << key << std::endl;
+ key = cvWaitKey(loopDelay);
+ //std::cout << "key: " << key << std::endl;
- if(key == KEY_SPACE)
- key = cvWaitKey(0);
+ if (key == KEY_SPACE)
+ key = cvWaitKey(0);
- if(key == KEY_ESC)
- break;
+ if (key == KEY_ESC)
+ break;
- if(stopAt > 0 && stopAt == frameNumber)
- key = cvWaitKey(0);
+ if (stopAt > 0 && stopAt == frameNumber)
+ key = cvWaitKey(0);
- firstTime = false;
- }while(1);
+ firstTime = false;
+ } while (1);
- cvReleaseCapture(&capture);
-}
+ cvReleaseCapture(&capture);
+ }
-void VideoCapture::saveConfig()
-{
- CvFileStorage* fs = cvOpenFileStorage("./config/VideoCapture.xml", 0, CV_STORAGE_WRITE);
-
- cvWriteInt(fs, "stopAt", stopAt);
- cvWriteInt(fs, "input_resize_percent", input_resize_percent);
- cvWriteInt(fs, "enableFlip", enableFlip);
- cvWriteInt(fs, "use_roi", VC_ROI::use_roi);
- cvWriteInt(fs, "roi_defined", VC_ROI::roi_defined);
- cvWriteInt(fs, "roi_x0", VC_ROI::roi_x0);
- cvWriteInt(fs, "roi_y0", VC_ROI::roi_y0);
- cvWriteInt(fs, "roi_x1", VC_ROI::roi_x1);
- cvWriteInt(fs, "roi_y1", VC_ROI::roi_y1);
- cvWriteInt(fs, "showOutput", showOutput);
-
- cvReleaseFileStorage(&fs);
-}
+ void VideoCapture::saveConfig()
+ {
+ CvFileStorage* fs = cvOpenFileStorage("./config/VideoCapture.xml", 0, CV_STORAGE_WRITE);
+
+ cvWriteInt(fs, "stopAt", stopAt);
+ cvWriteInt(fs, "input_resize_percent", input_resize_percent);
+ cvWriteInt(fs, "enableFlip", enableFlip);
+ cvWriteInt(fs, "use_roi", VC_ROI::use_roi);
+ cvWriteInt(fs, "roi_defined", VC_ROI::roi_defined);
+ cvWriteInt(fs, "roi_x0", VC_ROI::roi_x0);
+ cvWriteInt(fs, "roi_y0", VC_ROI::roi_y0);
+ cvWriteInt(fs, "roi_x1", VC_ROI::roi_x1);
+ cvWriteInt(fs, "roi_y1", VC_ROI::roi_y1);
+ cvWriteInt(fs, "showOutput", showOutput);
+
+ cvReleaseFileStorage(&fs);
+ }
-void VideoCapture::loadConfig()
-{
- CvFileStorage* fs = cvOpenFileStorage("./config/VideoCapture.xml", 0, CV_STORAGE_READ);
-
- stopAt = cvReadIntByName(fs, 0, "stopAt", 0);
- input_resize_percent = cvReadIntByName(fs, 0, "input_resize_percent", 100);
- enableFlip = cvReadIntByName(fs, 0, "enableFlip", false);
- VC_ROI::use_roi = cvReadIntByName(fs, 0, "use_roi", true);
- VC_ROI::roi_defined = cvReadIntByName(fs, 0, "roi_defined", false);
- VC_ROI::roi_x0 = cvReadIntByName(fs, 0, "roi_x0", 0);
- VC_ROI::roi_y0 = cvReadIntByName(fs, 0, "roi_y0", 0);
- VC_ROI::roi_x1 = cvReadIntByName(fs, 0, "roi_x1", 0);
- VC_ROI::roi_y1 = cvReadIntByName(fs, 0, "roi_y1", 0);
- showOutput = cvReadIntByName(fs, 0, "showOutput", true);
-
- cvReleaseFileStorage(&fs);
-}
\ No newline at end of file
+ void VideoCapture::loadConfig()
+ {
+ CvFileStorage* fs = cvOpenFileStorage("./config/VideoCapture.xml", 0, CV_STORAGE_READ);
+
+ stopAt = cvReadIntByName(fs, 0, "stopAt", 0);
+ input_resize_percent = cvReadIntByName(fs, 0, "input_resize_percent", 100);
+ enableFlip = cvReadIntByName(fs, 0, "enableFlip", false);
+ VC_ROI::use_roi = cvReadIntByName(fs, 0, "use_roi", true);
+ VC_ROI::roi_defined = cvReadIntByName(fs, 0, "roi_defined", false);
+ VC_ROI::roi_x0 = cvReadIntByName(fs, 0, "roi_x0", 0);
+ VC_ROI::roi_y0 = cvReadIntByName(fs, 0, "roi_y0", 0);
+ VC_ROI::roi_x1 = cvReadIntByName(fs, 0, "roi_x1", 0);
+ VC_ROI::roi_y1 = cvReadIntByName(fs, 0, "roi_y1", 0);
+ showOutput = cvReadIntByName(fs, 0, "showOutput", true);
+
+ cvReleaseFileStorage(&fs);
+ }
+}
diff --git a/VideoCapture.h b/VideoCapture.h
index caf6f6cb91d241a13bd9cac491d45a4ddf3897d2..1a381a8a9f566826fb99b2e39f9655c817756626 100644
--- a/VideoCapture.h
+++ b/VideoCapture.h
@@ -23,41 +23,43 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
#include "Config.h"
#include "IFrameProcessor.h"
-class VideoCapture
+namespace bgslibrary
{
-private:
- IFrameProcessor* frameProcessor;
- CvCapture* capture;
- IplImage* frame;
- int key;
- int64 start_time;
- int64 delta_time;
- double freq;
- double fps;
- long frameNumber;
- long stopAt;
- bool useCamera;
- int cameraIndex;
- bool useVideo;
- std::string videoFileName;
- int input_resize_percent;
- bool showOutput;
- bool enableFlip;
-
-public:
- VideoCapture();
- ~VideoCapture();
-
- void setFrameProcessor(IFrameProcessor* frameProcessorPtr);
- void setCamera(int cameraIndex);
- void setVideo(std::string filename);
- void start();
-
-private:
- void setUpCamera();
- void setUpVideo();
-
- void saveConfig();
- void loadConfig();
-};
+ class VideoCapture
+ {
+ private:
+ IFrameProcessor* frameProcessor;
+ CvCapture* capture;
+ IplImage* frame;
+ int key;
+ int64 start_time;
+ int64 delta_time;
+ double freq;
+ double fps;
+ long frameNumber;
+ long stopAt;
+ bool useCamera;
+ int cameraIndex;
+ bool useVideo;
+ std::string videoFileName;
+ int input_resize_percent;
+ bool showOutput;
+ bool enableFlip;
+ public:
+ VideoCapture();
+ ~VideoCapture();
+
+ void setFrameProcessor(IFrameProcessor* frameProcessorPtr);
+ void setCamera(int cameraIndex);
+ void setVideo(std::string filename);
+ void start();
+
+ private:
+ void setUpCamera();
+ void setUpVideo();
+
+ void saveConfig();
+ void loadConfig();
+ };
+}
diff --git a/bgslibrary.exe b/bgslibrary.exe
new file mode 100644
index 0000000000000000000000000000000000000000..5cbd4e2099cfd60482da69ac24ddd2acefa48c32
Binary files /dev/null and b/bgslibrary.exe differ
diff --git a/config/FrameProcessor.xml b/config/FrameProcessor.xml
index c76f826ebb87dd91db37552312138bf0f161fce3..9ff1a61df218a26630f1c7db93a9e36d63c7c638 100644
--- a/config/FrameProcessor.xml
+++ b/config/FrameProcessor.xml
@@ -30,9 +30,9 @@
<enableLBMixtureOfGaussians>0</enableLBMixtureOfGaussians>
<enableLBAdaptiveSOM>0</enableLBAdaptiveSOM>
<enableLBFuzzyAdaptiveSOM>0</enableLBFuzzyAdaptiveSOM>
-<enableLbpMrf>0</enableLbpMrf>
<enableMultiLayerBGS>0</enableMultiLayerBGS>
-<enablePBAS>0</enablePBAS>
<enableVuMeter>0</enableVuMeter>
<enableKDE>0</enableKDE>
+<enableIMBS>0</enableIMBS>
+<enableMultiCueBGS>0</enableMultiCueBGS>
</opencv_storage>
diff --git a/package_analysis/ForegroundMaskAnalysis.cpp b/package_analysis/ForegroundMaskAnalysis.cpp
index 45645a01e3feb98ce478cca89ef9754c29d99f52..4df9ed0c10933c0ad8051538d0e6f8435d46bd7c 100644
--- a/package_analysis/ForegroundMaskAnalysis.cpp
+++ b/package_analysis/ForegroundMaskAnalysis.cpp
@@ -16,86 +16,89 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
*/
#include "ForegroundMaskAnalysis.h"
-ForegroundMaskAnalysis::ForegroundMaskAnalysis() : firstTime(true), stopAt(0), showOutput(true), img_ref_path("")
+namespace bgslibrary
{
- std::cout << "ForegroundMaskAnalysis()" << std::endl;
-}
-
-ForegroundMaskAnalysis::~ForegroundMaskAnalysis()
-{
- std::cout << "~ForegroundMaskAnalysis()" << std::endl;
-}
-
-void ForegroundMaskAnalysis::process(const long &frameNumber, const std::string &name, const cv::Mat &img_input)
-{
- if(img_input.empty())
- return;
-
- if(stopAt == 0)
+ ForegroundMaskAnalysis::ForegroundMaskAnalysis() : firstTime(true), stopAt(0), showOutput(true), img_ref_path("")
{
- loadConfig();
-
- if(firstTime)
- saveConfig();
+ std::cout << "ForegroundMaskAnalysis()" << std::endl;
}
- if(stopAt == frameNumber && img_ref_path.empty() == false)
+ ForegroundMaskAnalysis::~ForegroundMaskAnalysis()
{
- cv::Mat img_ref = cv::imread(img_ref_path, 0);
-
- if(showOutput)
- cv::imshow("ForegroundMaskAnalysis", img_ref);
+ std::cout << "~ForegroundMaskAnalysis()" << std::endl;
+ }
- int rn = cv::countNonZero(img_ref);
- cv::Mat i;
- cv::Mat u;
+ void ForegroundMaskAnalysis::process(const long &frameNumber, const std::string &name, const cv::Mat &img_input)
+ {
+ if (img_input.empty())
+ return;
- if(rn > 0)
- {
- i = img_input & img_ref;
- u = img_input | img_ref;
- }
- else
+ if (stopAt == 0)
{
- i = (~img_input) & (~img_ref);
- u = (~img_input) | (~img_ref);
+ loadConfig();
+
+ if (firstTime)
+ saveConfig();
}
- int in = cv::countNonZero(i);
- int un = cv::countNonZero(u);
-
- double s = (((double)in) / ((double)un));
-
- if(showOutput)
+ if (stopAt == frameNumber && img_ref_path.empty() == false)
{
- cv::imshow("A^B", i);
- cv::imshow("AvB", u);
- }
+ cv::Mat img_ref = cv::imread(img_ref_path, 0);
+
+ if (showOutput)
+ cv::imshow("ForegroundMaskAnalysis", img_ref);
+
+ int rn = cv::countNonZero(img_ref);
+ cv::Mat i;
+ cv::Mat u;
- std::cout << name << " - Similarity Measure: " << s << " press ENTER to continue" << std::endl;
+ if (rn > 0)
+ {
+ i = img_input & img_ref;
+ u = img_input | img_ref;
+ }
+ else
+ {
+ i = (~img_input) & (~img_ref);
+ u = (~img_input) | (~img_ref);
+ }
- cv::waitKey(0);
+ int in = cv::countNonZero(i);
+ int un = cv::countNonZero(u);
+
+ double s = (((double)in) / ((double)un));
+
+ if (showOutput)
+ {
+ cv::imshow("A^B", i);
+ cv::imshow("AvB", u);
+ }
+
+ std::cout << name << " - Similarity Measure: " << s << " press ENTER to continue" << std::endl;
+
+ cv::waitKey(0);
+ }
+
+ firstTime = false;
}
- firstTime = false;
-}
+ void ForegroundMaskAnalysis::saveConfig()
+ {
+ CvFileStorage* fs = cvOpenFileStorage("./config/ForegroundMaskAnalysis.xml", 0, CV_STORAGE_WRITE);
-void ForegroundMaskAnalysis::saveConfig()
-{
- CvFileStorage* fs = cvOpenFileStorage("./config/ForegroundMaskAnalysis.xml", 0, CV_STORAGE_WRITE);
+ cvWriteInt(fs, "stopAt", stopAt);
+ cvWriteString(fs, "img_ref_path", img_ref_path.c_str());
- cvWriteInt(fs, "stopAt", stopAt);
- cvWriteString(fs, "img_ref_path", img_ref_path.c_str());
-
- cvReleaseFileStorage(&fs);
-}
+ cvReleaseFileStorage(&fs);
+ }
-void ForegroundMaskAnalysis::loadConfig()
-{
- CvFileStorage* fs = cvOpenFileStorage("./config/ForegroundMaskAnalysis.xml", 0, CV_STORAGE_READ);
-
- stopAt = cvReadIntByName(fs, 0, "stopAt", 0);
- img_ref_path = cvReadStringByName(fs, 0, "img_ref_path", "");
+ void ForegroundMaskAnalysis::loadConfig()
+ {
+ CvFileStorage* fs = cvOpenFileStorage("./config/ForegroundMaskAnalysis.xml", 0, CV_STORAGE_READ);
+
+ stopAt = cvReadIntByName(fs, 0, "stopAt", 0);
+ img_ref_path = cvReadStringByName(fs, 0, "img_ref_path", "");
- cvReleaseFileStorage(&fs);
-}
\ No newline at end of file
+ cvReleaseFileStorage(&fs);
+ }
+}
diff --git a/package_analysis/ForegroundMaskAnalysis.h b/package_analysis/ForegroundMaskAnalysis.h
index d6bfdaea123037b8b9b0d380910c84124a28204c..399da68c211d8fd8f93ef96beecca1452d532a24 100644
--- a/package_analysis/ForegroundMaskAnalysis.h
+++ b/package_analysis/ForegroundMaskAnalysis.h
@@ -21,22 +21,25 @@ along with BGSLibrary. If not, see <http://www.gnu.org/licenses/>.
#include <cv.h>
#include <highgui.h>
-class ForegroundMaskAnalysis
+namespace bgslibrary
{
-private:
- bool firstTime;
- bool showOutput;
-
-public:
- ForegroundMaskAnalysis();
- ~ForegroundMaskAnalysis();
-
- long stopAt;
- std::string img_ref_path;
-
- void process(const long &frameNumber, const std::string &name, const cv::Mat &img_input);
-
-private:
- void saveConfig();
- void loadConfig();
-};
\ No newline at end of file
+ class ForegroundMaskAnalysis
+ {
+ private:
+ bool firstTime;
+ bool showOutput;
+
+ public:
+ ForegroundMaskAnalysis();
+ ~ForegroundMaskAnalysis();
+
+ long stopAt;
+ std::string img_ref_path;
+
+ void process(const long &frameNumber, const std::string &name, const cv::Mat &img_input);
+
+ private:
+ void saveConfig();
+ void loadConfig();
+ };
+}
diff --git a/vs2010/bgslibrary.v12.suo b/vs2010/bgslibrary.v12.suo
index e515299c25c150bf36a9f790adfcab547564d2cf..318f0336bf43288341f2a845a4a0e9b1eff5180c 100644
Binary files a/vs2010/bgslibrary.v12.suo and b/vs2010/bgslibrary.v12.suo differ
diff --git a/vs2010/bgslibrary.vcxproj b/vs2010/bgslibrary.vcxproj
index d9c829d9b13e21605bf2c7884293325a8ef63532..a1bddf6930ec4de042f5c75fd7d7b380ab69bf75 100644
--- a/vs2010/bgslibrary.vcxproj
+++ b/vs2010/bgslibrary.vcxproj
@@ -78,7 +78,12 @@
</Link>
</ItemDefinitionGroup>
<ItemGroup>
- <ClCompile Include="..\Demo.cpp" />
+ <ClCompile Include="..\Demo.cpp">
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+ </ClCompile>
+ <ClCompile Include="..\FrameProcessor.cpp" />
+ <ClCompile Include="..\Main.cpp" />
+ <ClCompile Include="..\package_analysis\ForegroundMaskAnalysis.cpp" />
<ClCompile Include="..\package_bgs\AdaptiveBackgroundLearning.cpp" />
<ClCompile Include="..\package_bgs\AdaptiveSelectiveBackgroundLearning.cpp" />
<ClCompile Include="..\package_bgs\ae\KDE.cpp" />
@@ -145,8 +150,15 @@
<ClCompile Include="..\package_bgs\tb\T2FMRF_UV.cpp" />
<ClCompile Include="..\package_bgs\WeightedMovingMeanBGS.cpp" />
<ClCompile Include="..\package_bgs\WeightedMovingVarianceBGS.cpp" />
+ <ClCompile Include="..\PreProcessor.cpp" />
+ <ClCompile Include="..\VideoAnalysis.cpp" />
+ <ClCompile Include="..\VideoCapture.cpp" />
</ItemGroup>
<ItemGroup>
+ <ClInclude Include="..\Config.h" />
+ <ClInclude Include="..\FrameProcessor.h" />
+ <ClInclude Include="..\IFrameProcessor.h" />
+ <ClInclude Include="..\package_analysis\ForegroundMaskAnalysis.h" />
<ClInclude Include="..\package_bgs\AdaptiveBackgroundLearning.h" />
<ClInclude Include="..\package_bgs\AdaptiveSelectiveBackgroundLearning.h" />
<ClInclude Include="..\package_bgs\ae\KDE.h" />
@@ -221,6 +233,9 @@
<ClInclude Include="..\package_bgs\tb\T2FMRF_UV.h" />
<ClInclude Include="..\package_bgs\WeightedMovingMeanBGS.h" />
<ClInclude Include="..\package_bgs\WeightedMovingVarianceBGS.h" />
+ <ClInclude Include="..\PreProcessor.h" />
+ <ClInclude Include="..\VideoAnalysis.h" />
+ <ClInclude Include="..\VideoCapture.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
diff --git a/vs2010/bgslibrary.vcxproj.filters b/vs2010/bgslibrary.vcxproj.filters
index 3960cbf0894f8d0f76aaef4d0c665851d1e3f1d5..f91c2cc38b74bc9d99526a9bcdf3c9eccdd53f38 100644
--- a/vs2010/bgslibrary.vcxproj.filters
+++ b/vs2010/bgslibrary.vcxproj.filters
@@ -43,11 +43,14 @@
<Filter Include="Header Files\package_bgs\tb">
<UniqueIdentifier>{53f2c4fb-9468-44ce-b76e-e25ea018c084}</UniqueIdentifier>
</Filter>
+ <Filter Include="Source Files\demo">
+ <UniqueIdentifier>{23f1cd4a-e9b2-4338-a5e7-128f451d3c89}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="Header Files\package_analysis">
+ <UniqueIdentifier>{52a9f254-d817-4577-96c2-0b3b0a9527b7}</UniqueIdentifier>
+ </Filter>
</ItemGroup>
<ItemGroup>
- <ClCompile Include="..\Demo.cpp">
- <Filter>Source Files</Filter>
- </ClCompile>
<ClCompile Include="..\package_bgs\AdaptiveBackgroundLearning.cpp">
<Filter>Header Files\package_bgs</Filter>
</ClCompile>
@@ -207,12 +210,6 @@
<ClCompile Include="..\package_bgs\lb\LBSimpleGaussian.cpp">
<Filter>Header Files\package_bgs\lb</Filter>
</ClCompile>
- <ClCompile Include="..\package_bgs\pt\PBAS.cpp">
- <Filter>Header Files\package_bgs\pt</Filter>
- </ClCompile>
- <ClCompile Include="..\package_bgs\pt\PixelBasedAdaptiveSegmenter.cpp">
- <Filter>Header Files\package_bgs\pt</Filter>
- </ClCompile>
<ClCompile Include="..\package_bgs\sjn\SJN_MultiCueBGS.cpp">
<Filter>Header Files\package_bgs\sjn</Filter>
</ClCompile>
@@ -252,6 +249,27 @@
<ClCompile Include="..\package_bgs\tb\T2FMRF_UV.cpp">
<Filter>Header Files\package_bgs\tb</Filter>
</ClCompile>
+ <ClCompile Include="..\FrameProcessor.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="..\Main.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="..\PreProcessor.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="..\VideoAnalysis.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="..\VideoCapture.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="..\Demo.cpp">
+ <Filter>Source Files\demo</Filter>
+ </ClCompile>
+ <ClCompile Include="..\package_analysis\ForegroundMaskAnalysis.cpp">
+ <Filter>Header Files\package_analysis</Filter>
+ </ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\package_bgs\AdaptiveBackgroundLearning.h">
@@ -437,12 +455,6 @@
<ClInclude Include="..\package_bgs\lb\Types.h">
<Filter>Header Files\package_bgs\lb</Filter>
</ClInclude>
- <ClInclude Include="..\package_bgs\pt\PBAS.h">
- <Filter>Header Files\package_bgs\pt</Filter>
- </ClInclude>
- <ClInclude Include="..\package_bgs\pt\PixelBasedAdaptiveSegmenter.h">
- <Filter>Header Files\package_bgs\pt</Filter>
- </ClInclude>
<ClInclude Include="..\package_bgs\sjn\SJN_MultiCueBGS.h">
<Filter>Header Files\package_bgs\sjn</Filter>
</ClInclude>
@@ -482,5 +494,26 @@
<ClInclude Include="..\package_bgs\tb\T2FMRF_UV.h">
<Filter>Header Files\package_bgs\tb</Filter>
</ClInclude>
+ <ClInclude Include="..\Config.h">
+ <Filter>Source Files</Filter>
+ </ClInclude>
+ <ClInclude Include="..\FrameProcessor.h">
+ <Filter>Source Files</Filter>
+ </ClInclude>
+ <ClInclude Include="..\IFrameProcessor.h">
+ <Filter>Source Files</Filter>
+ </ClInclude>
+ <ClInclude Include="..\PreProcessor.h">
+ <Filter>Source Files</Filter>
+ </ClInclude>
+ <ClInclude Include="..\VideoAnalysis.h">
+ <Filter>Source Files</Filter>
+ </ClInclude>
+ <ClInclude Include="..\VideoCapture.h">
+ <Filter>Source Files</Filter>
+ </ClInclude>
+ <ClInclude Include="..\package_analysis\ForegroundMaskAnalysis.h">
+ <Filter>Header Files\package_analysis</Filter>
+ </ClInclude>
</ItemGroup>
</Project>
\ No newline at end of file