refactored video module; use the new-style algorithms now

modules/contrib/src/facerec.cpp

@@ -893,7 +893,7 @@ CV_INIT_ALGORITHM(LBPH, "FaceRecognizer.LBPH",
 
 bool initModule_contrib()
 {
-    Ptr<Algorithm> efaces = createEigenfaces(), ffaces = createFisherfaces(), lbph = createLBPH();
+    Ptr<Algorithm> efaces = createEigenfaces_hidden(), ffaces = createFisherfaces_hidden(), lbph = createLBPH_hidden();
     return efaces->info() != 0 && ffaces->info() != 0 && lbph->info() != 0;
 }
 

modules/core/include/opencv2/core/internal.hpp

@@ -254,14 +254,14 @@ namespace cv
 } //namespace cv
 
 #define CV_INIT_ALGORITHM(classname, algname, memberinit) \
-    static ::cv::Algorithm* create##classname() \
+    static ::cv::Algorithm* create##classname##_hidden() \
     { \
         return new classname; \
     } \
     \
     static ::cv::AlgorithmInfo& classname##_info() \
     { \
-        static ::cv::AlgorithmInfo classname##_info_var(algname, create##classname); \
+        static ::cv::AlgorithmInfo classname##_info_var(algname, create##classname##_hidden); \
         return classname##_info_var; \
     } \
     \

modules/gpu/perf/perf_video.cpp

@@ -614,10 +614,10 @@ PERF_TEST_P(Video_Cn_LearningRate, Video_MOG,
     }
     else
     {
-        cv::BackgroundSubtractorMOG mog;
+        cv::Ptr<cv::BackgroundSubtractor> mog = cv::createBackgroundSubtractorMOG();
         cv::Mat foreground;
 
-        mog(frame, foreground, learningRate);
+        mog->apply(frame, foreground, learningRate);
 
         for (int i = 0; i < 10; ++i)
         {
@@ -635,7 +635,7 @@ PERF_TEST_P(Video_Cn_LearningRate, Video_MOG,
             }
 
             startTimer(); next();
-            mog(frame, foreground, learningRate);
+            mog->apply(frame, foreground, learningRate);
             stopTimer();
         }
 
@@ -709,12 +709,12 @@ PERF_TEST_P(Video_Cn, Video_MOG2,
     }
     else
     {
-        cv::BackgroundSubtractorMOG2 mog2;
-        mog2.set("detectShadows", false);
+        cv::Ptr<cv::BackgroundSubtractor> mog2 = cv::createBackgroundSubtractorMOG2();
+        mog2->set("detectShadows", false);
 
         cv::Mat foreground;
 
-        mog2(frame, foreground);
+        mog2->apply(frame, foreground);
 
         for (int i = 0; i < 10; ++i)
         {
@@ -732,7 +732,7 @@ PERF_TEST_P(Video_Cn, Video_MOG2,
             }
 
             startTimer(); next();
-            mog2(frame, foreground);
+            mog2->apply(frame, foreground);
             stopTimer();
         }
 
@@ -789,7 +789,7 @@ PERF_TEST_P(Video_Cn, Video_MOG2GetBackgroundImage,
     }
     else
     {
-        cv::BackgroundSubtractorMOG2 mog2;
+        cv::Ptr<cv::BackgroundSubtractor> mog2 = cv::createBackgroundSubtractorMOG2();
         cv::Mat foreground;
 
         for (int i = 0; i < 10; ++i)
@@ -807,12 +807,12 @@ PERF_TEST_P(Video_Cn, Video_MOG2GetBackgroundImage,
                 cv::swap(temp, frame);
             }
 
-            mog2(frame, foreground);
+            mog2->apply(frame, foreground);
         }
 
         cv::Mat background;
 
-        TEST_CYCLE() mog2.getBackgroundImage(background);
+        TEST_CYCLE() mog2->getBackgroundImage(background);
 
         CPU_SANITY_CHECK(background);
     }
@@ -958,11 +958,11 @@ PERF_TEST_P(Video_Cn_MaxFeatures, Video_GMG,
         cv::Mat foreground;
         cv::Mat zeros(frame.size(), CV_8UC1, cv::Scalar::all(0));
 
-        cv::BackgroundSubtractorGMG gmg;
-        gmg.set("maxFeatures", maxFeatures);
-        gmg.initialize(frame.size(), 0.0, 255.0);
+        cv::Ptr<cv::BackgroundSubtractor> gmg = cv::createBackgroundSubtractorGMG();
+        gmg->set("maxFeatures", maxFeatures);
+        //gmg.initialize(frame.size(), 0.0, 255.0);
 
-        gmg(frame, foreground);
+        gmg->apply(frame, foreground);
 
         for (int i = 0; i < 150; ++i)
         {
@@ -985,7 +985,7 @@ PERF_TEST_P(Video_Cn_MaxFeatures, Video_GMG,
             }
 
             startTimer(); next();
-            gmg(frame, foreground);
+            gmg->apply(frame, foreground);
             stopTimer();
         }
 

modules/gpu/test/test_bgfg.cpp

@@ -245,8 +245,8 @@ GPU_TEST_P(MOG2, Update)
     mog2.bShadowDetection = detectShadow;
     cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
 
-    cv::BackgroundSubtractorMOG2 mog2_gold;
-    mog2_gold.set("detectShadows", detectShadow);
+    cv::Ptr<cv::BackgroundSubtractorMOG2> mog2_gold = cv::createBackgroundSubtractorMOG2();
+    mog2_gold.setDetectShadows(detectShadow);
     cv::Mat foreground_gold;
 
     for (int i = 0; i < 10; ++i)
@@ -263,7 +263,7 @@ GPU_TEST_P(MOG2, Update)
 
         mog2(loadMat(frame, useRoi), foreground);
 
-        mog2_gold(frame, foreground_gold);
+        mog2_gold->apply(frame, foreground_gold);
 
         if (detectShadow)
         {
@@ -290,8 +290,8 @@ GPU_TEST_P(MOG2, getBackgroundImage)
     mog2.bShadowDetection = detectShadow;
     cv::gpu::GpuMat foreground;
 
-    cv::BackgroundSubtractorMOG2 mog2_gold;
-    mog2_gold.set("detectShadows", detectShadow);
+    cv::Ptr<cv::BackgroundSubtractorMOG2> mog2_gold = cv::createBackgroundSubtractorMOG2();
+    mog2_gold.setDetectShadows(detectShadow);
     cv::Mat foreground_gold;
 
     for (int i = 0; i < 10; ++i)
@@ -301,14 +301,14 @@ GPU_TEST_P(MOG2, getBackgroundImage)
 
         mog2(loadMat(frame, useRoi), foreground);
 
-        mog2_gold(frame, foreground_gold);
+        mog2_gold->apply(frame, foreground_gold);
     }
 
     cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi);
     mog2.getBackgroundImage(background);
 
     cv::Mat background_gold;
-    mog2_gold.getBackgroundImage(background_gold);
+    mog2_gold->getBackgroundImage(background_gold);
 
     ASSERT_MAT_NEAR(background_gold, background, 0);
 }

modules/legacy/src/bgfg_gaussmix.cpp

@@ -50,7 +50,7 @@ icvReleaseGaussianBGModel( CvGaussBGModel** bg_model )
 
     if( *bg_model )
     {
-        delete (cv::BackgroundSubtractorMOG*)((*bg_model)->mog);
+        delete (cv::Ptr<cv::BackgroundSubtractor>*)((*bg_model)->mog);
         cvReleaseImage( &(*bg_model)->background );
         cvReleaseImage( &(*bg_model)->foreground );
         memset( *bg_model, 0, sizeof(**bg_model) );
@@ -65,10 +65,10 @@ icvUpdateGaussianBGModel( IplImage* curr_frame, CvGaussBGModel*  bg_model, doubl
 {
     cv::Mat image = cv::cvarrToMat(curr_frame), mask = cv::cvarrToMat(bg_model->foreground);
 
-    cv::BackgroundSubtractorMOG* mog = (cv::BackgroundSubtractorMOG*)(bg_model->mog);
+    cv::Ptr<cv::BackgroundSubtractor>* mog = (cv::Ptr<cv::BackgroundSubtractor>*)(bg_model->mog);
     CV_Assert(mog != 0);
 
-    (*mog)(image, mask, learningRate);
+    (*mog)->apply(image, mask, learningRate);
     bg_model->countFrames++;
 
     return 0;
@@ -105,13 +105,11 @@ cvCreateGaussianBGModel( IplImage* first_frame, CvGaussBGStatModelParams* parame
 
     bg_model->params = params;
 
-    cv::BackgroundSubtractorMOG* mog =
-        new cv::BackgroundSubtractorMOG(params.win_size,
-                                        params.n_gauss,
-                                        params.bg_threshold,
-                                        params.variance_init);
-
-    bg_model->mog = mog;
+    cv::Ptr<cv::BackgroundSubtractor> mog = cv::createBackgroundSubtractorMOG(params.win_size, params.n_gauss,
+                                                                              params.bg_threshold);
+    cv::Ptr<cv::BackgroundSubtractor>* pmog = new cv::Ptr<cv::BackgroundSubtractor>;
+    *pmog = mog;
+    bg_model->mog = pmog;
 
     CvSize sz = cvGetSize(first_frame);
     bg_model->background = cvCreateImage(sz, IPL_DEPTH_8U, first_frame->nChannels);

modules/ml/src/ml_init.cpp

@@ -56,7 +56,7 @@ CV_INIT_ALGORITHM(EM, "StatModel.EM",
 
 bool initModule_ml(void)
 {
-    Ptr<Algorithm> em = createEM();
+    Ptr<Algorithm> em = createEM_hidden();
     return em->info() != 0;
 }
 

modules/nonfree/src/nonfree_init.cpp

@@ -67,7 +67,7 @@ CV_INIT_ALGORITHM(SIFT, "Feature2D.SIFT",
 
 bool initModule_nonfree(void)
 {
-    Ptr<Algorithm> sift = createSIFT(), surf = createSURF();
+    Ptr<Algorithm> sift = createSIFT_hidden(), surf = createSURF_hidden();
     return sift->info() != 0 && surf->info() != 0;
 }
 

modules/python/src2/cv2.cpp

@@ -125,6 +125,7 @@ typedef Ptr<FeatureDetector> Ptr_FeatureDetector;
 typedef Ptr<DescriptorExtractor> Ptr_DescriptorExtractor;
 typedef Ptr<Feature2D> Ptr_Feature2D;
 typedef Ptr<DescriptorMatcher> Ptr_DescriptorMatcher;
+typedef Ptr<BackgroundSubtractor> Ptr_BackgroundSubtractor;
 
 typedef Ptr<cv::softcascade::ChannelFeatureBuilder> Ptr_ChannelFeatureBuilder;
 

modules/softcascade/src/softcascade_init.cpp

@@ -58,8 +58,8 @@ CV_INIT_ALGORITHM(SCascade, "CascadeDetector.SCascade",
 
 bool initModule_softcascade(void)
 {
-    Ptr<Algorithm> sc = createSCascade();
-    Ptr<Algorithm> sc1 = createDetector();
+    Ptr<Algorithm> sc = createSCascade_hidden();
+    Ptr<Algorithm> sc1 = createDetector_hidden();
     return (sc1->info() != 0) && (sc->info() != 0);
 }
 

modules/video/include/opencv2/video/tracking.hpp

@@ -219,23 +219,6 @@ CVAPI(const CvMat*)  cvKalmanCorrect( CvKalman* kalman, const CvMat* measurement
 #define cvKalmanUpdateByMeasurement cvKalmanCorrect
 
 
-/****************************************************************************************\
-*                                       Image Alignment (ECC algorithm)                  *
-\****************************************************************************************/
-enum
-{
-    MOTION_TRANSLATION,
-    MOTION_EUCLIDEAN,
-    MOTION_AFFINE,
-    MOTION_HOMOGRAPHY
-};
-
-/* Estimate the geometric transformation between 2 images (area-based alignment) */
-CVAPI(double)  cvFindTransformECC (const CvArr* templateImage, const CvArr* inputImage,
-                                   CvMat* warpMatrix,
-                                   const int motionType,
-                                   const CvTermCriteria criteria);
-
 #ifdef __cplusplus
 }
 
@@ -341,6 +324,14 @@ CV_EXPORTS_W void calcOpticalFlowFarneback( InputArray prev, InputArray next,
 CV_EXPORTS_W Mat estimateRigidTransform( InputArray src, InputArray dst,
                                          bool fullAffine);
 
+enum
+{
+    MOTION_TRANSLATION=0,
+    MOTION_EUCLIDEAN=1,
+    MOTION_AFFINE=2,
+    MOTION_HOMOGRAPHY=3
+};
+
 //! estimates the best-fit Translation, Euclidean, Affine or Perspective Transformation
 // with respect to Enhanced Correlation Coefficient criterion that maps one image to
 // another (area-based alignment)

modules/video/src/bgfg_gaussmix.cpp

@@ -7,9 +7,11 @@
 //  copy or use the software.
 //
 //
-//                        Intel License Agreement
+//                          License Agreement
+//                For Open Source Computer Vision Library
 //
 // Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
 // Third party copyrights are property of their respective owners.
 //
 // Redistribution and use in source and binary forms, with or without modification,
@@ -22,7 +24,7 @@
 //     this list of conditions and the following disclaimer in the documentation
 //     and/or other materials provided with the distribution.
 //
-//   * The name of Intel Corporation may not be used to endorse or promote products
+//   * The name of the copyright holders may not be used to endorse or promote products
 //     derived from this software without specific prior written permission.
 //
 // This software is provided by the copyright holders and contributors "as is" and
@@ -58,15 +60,6 @@
 namespace cv
 {
 
-BackgroundSubtractor::~BackgroundSubtractor() {}
-void BackgroundSubtractor::operator()(InputArray, OutputArray, double)
-{
-}
-
-void BackgroundSubtractor::getBackgroundImage(OutputArray) const
-{
-}
-
 static const int defaultNMixtures = 5;
 static const int defaultHistory = 200;
 static const double defaultBackgroundRatio = 0.7;
@@ -74,55 +67,88 @@ static const double defaultVarThreshold = 2.5*2.5;
 static const double defaultNoiseSigma = 30*0.5;
 static const double defaultInitialWeight = 0.05;
 
-BackgroundSubtractorMOG::BackgroundSubtractorMOG()
+class BackgroundSubtractorMOGImpl : public BackgroundSubtractorMOG
 {
-    frameSize = Size(0,0);
-    frameType = 0;
-
-    nframes = 0;
-    nmixtures = defaultNMixtures;
-    history = defaultHistory;
-    varThreshold = defaultVarThreshold;
-    backgroundRatio = defaultBackgroundRatio;
-    noiseSigma = defaultNoiseSigma;
-}
+public:
+    //! the default constructor
+    BackgroundSubtractorMOGImpl()
+    {
+        frameSize = Size(0,0);
+        frameType = 0;
+
+        nframes = 0;
+        nmixtures = defaultNMixtures;
+        history = defaultHistory;
+        varThreshold = defaultVarThreshold;
+        backgroundRatio = defaultBackgroundRatio;
+        noiseSigma = defaultNoiseSigma;
+    }
+    // the full constructor that takes the length of the history,
+    // the number of gaussian mixtures, the background ratio parameter and the noise strength
+    BackgroundSubtractorMOGImpl(int _history, int _nmixtures, double _backgroundRatio, double _noiseSigma=0)
+    {
+        frameSize = Size(0,0);
+        frameType = 0;
+
+        nframes = 0;
+        nmixtures = std::min(_nmixtures > 0 ? _nmixtures : defaultNMixtures, 8);
+        history = _history > 0 ? _history : defaultHistory;
+        varThreshold = defaultVarThreshold;
+        backgroundRatio = std::min(_backgroundRatio > 0 ? _backgroundRatio : 0.95, 1.);
+        noiseSigma = _noiseSigma <= 0 ? defaultNoiseSigma : _noiseSigma;
+    }
 
-BackgroundSubtractorMOG::BackgroundSubtractorMOG(int _history, int _nmixtures,
-                                                 double _backgroundRatio,
-                                                 double _noiseSigma)
-{
-    frameSize = Size(0,0);
-    frameType = 0;
-
-    nframes = 0;
-    nmixtures = std::min(_nmixtures > 0 ? _nmixtures : defaultNMixtures, 8);
-    history = _history > 0 ? _history : defaultHistory;
-    varThreshold = defaultVarThreshold;
-    backgroundRatio = std::min(_backgroundRatio > 0 ? _backgroundRatio : 0.95, 1.);
-    noiseSigma = _noiseSigma <= 0 ? defaultNoiseSigma : _noiseSigma;
-}
+    //! the update operator
+    virtual void apply(InputArray image, OutputArray fgmask, double learningRate=0);
 
-BackgroundSubtractorMOG::~BackgroundSubtractorMOG()
-{
-}
+    //! re-initiaization method
+    virtual void initialize(Size _frameSize, int _frameType)
+    {
+        frameSize = _frameSize;
+        frameType = _frameType;
+        nframes = 0;
+
+        int nchannels = CV_MAT_CN(frameType);
+        CV_Assert( CV_MAT_DEPTH(frameType) == CV_8U );
+
+        // for each gaussian mixture of each pixel bg model we store ...
+        // the mixture sort key (w/sum_of_variances), the mixture weight (w),
+        // the mean (nchannels values) and
+        // the diagonal covariance matrix (another nchannels values)
+        bgmodel.create( 1, frameSize.height*frameSize.width*nmixtures*(2 + 2*nchannels), CV_32F );
+        bgmodel = Scalar::all(0);
+    }
 
+    virtual AlgorithmInfo* info() const { return 0; }
 
-void BackgroundSubtractorMOG::initialize(Size _frameSize, int _frameType)
-{
-    frameSize = _frameSize;
-    frameType = _frameType;
-    nframes = 0;
-
-    int nchannels = CV_MAT_CN(frameType);
-    CV_Assert( CV_MAT_DEPTH(frameType) == CV_8U );
-
-    // for each gaussian mixture of each pixel bg model we store ...
-    // the mixture sort key (w/sum_of_variances), the mixture weight (w),
-    // the mean (nchannels values) and
-    // the diagonal covariance matrix (another nchannels values)
-    bgmodel.create( 1, frameSize.height*frameSize.width*nmixtures*(2 + 2*nchannels), CV_32F );
-    bgmodel = Scalar::all(0);
-}
+    virtual void getBackgroundImage(OutputArray) const
+    {
+        CV_Error( CV_StsNotImplemented, "" );
+    }
+
+    virtual int getHistory() const { return history; }
+    virtual void setHistory(int _nframes) { history = _nframes; }
+
+    virtual int getNMixtures() const { return nmixtures; }
+    virtual void setNMixtures(int nmix) { nmixtures = nmix; }
+
+    virtual double getBackgroundRatio() const { return backgroundRatio; }
+    virtual void setBackgroundRatio(double _backgroundRatio) { backgroundRatio = _backgroundRatio; }
+
+    virtual double getNoiseSigma() const { return noiseSigma; }
+    virtual void setNoiseSigma(double _noiseSigma) { noiseSigma = _noiseSigma; }
+
+protected:
+    Size frameSize;
+    int frameType;
+    Mat bgmodel;
+    int nframes;
+    int history;
+    int nmixtures;
+    double varThreshold;
+    double backgroundRatio;
+    double noiseSigma;
+};
 
 
 template<typename VT> struct MixData
@@ -391,7 +417,7 @@ static void process8uC3( const Mat& image, Mat& fgmask, double learningRate,
     }
 }
 
-void BackgroundSubtractorMOG::operator()(InputArray _image, OutputArray _fgmask, double learningRate)
+void BackgroundSubtractorMOGImpl::apply(InputArray _image, OutputArray _fgmask, double learningRate)
 {
     Mat image = _image.getMat();
     bool needToInitialize = nframes == 0 || learningRate >= 1 || image.size() != frameSize || image.type() != frameType;
@@ -415,6 +441,12 @@ void BackgroundSubtractorMOG::operator()(InputArray _image, OutputArray _fgmask,
         CV_Error( CV_StsUnsupportedFormat, "Only 1- and 3-channel 8-bit images are supported in BackgroundSubtractorMOG" );
 }
 
+Ptr<BackgroundSubtractorMOG> createBackgroundSubtractorMOG(int history, int nmixtures,
+                                  double backgroundRatio, double noiseSigma)
+{
+    return new BackgroundSubtractorMOGImpl(history, nmixtures, backgroundRatio, noiseSigma);
+}
+
 }
 
 /* End of file. */

modules/video/src/ecc.cpp

@@ -305,23 +305,8 @@ static void update_warping_matrix_ECC (Mat& map_matrix, const Mat& update, const
         mapPtr[3] = (float) sin(new_theta);
         mapPtr[1] = -mapPtr[3];
     }
-
 }
 
-CV_IMPL double cvFindTransformECC (const CvArr* _image1, const CvArr* _image2,
-                                   CvMat* _map_matrix,
-                                   const int motionType,
-                                   const CvTermCriteria _criteria)
-{
-
-    Mat image1 = cvarrToMat(_image1);
-    Mat image2 = cvarrToMat(_image2);
-    Mat map_matrix = cvarrToMat(_map_matrix);
-    double cc = cv::findTransformECC(image1, image2, map_matrix, motionType,
-        TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, _criteria.max_iter, _criteria.epsilon));
-
-    return cc;
-}
 
 double cv::findTransformECC(InputArray templateImage,
                             InputArray inputImage,

modules/video/src/kalman.cpp

@@ -40,176 +40,6 @@
 //M*/
 #include "precomp.hpp"
 
-
-CV_IMPL CvKalman*
-cvCreateKalman( int DP, int MP, int CP )
-{
-    CvKalman *kalman = 0;
-
-    if( DP <= 0 || MP <= 0 )
-        CV_Error( CV_StsOutOfRange,
-        "state and measurement vectors must have positive number of dimensions" );
-
-    if( CP < 0 )
-        CP = DP;
-
-    /* allocating memory for the structure */
-    kalman = (CvKalman *)cvAlloc( sizeof( CvKalman ));
-    memset( kalman, 0, sizeof(*kalman));
-
-    kalman->DP = DP;
-    kalman->MP = MP;
-    kalman->CP = CP;
-
-    kalman->state_pre = cvCreateMat( DP, 1, CV_32FC1 );
-    cvZero( kalman->state_pre );
-
-    kalman->state_post = cvCreateMat( DP, 1, CV_32FC1 );
-    cvZero( kalman->state_post );
-
-    kalman->transition_matrix = cvCreateMat( DP, DP, CV_32FC1 );
-    cvSetIdentity( kalman->transition_matrix );
-
-    kalman->process_noise_cov = cvCreateMat( DP, DP, CV_32FC1 );
-    cvSetIdentity( kalman->process_noise_cov );
-
-    kalman->measurement_matrix = cvCreateMat( MP, DP, CV_32FC1 );
-    cvZero( kalman->measurement_matrix );
-
-    kalman->measurement_noise_cov = cvCreateMat( MP, MP, CV_32FC1 );
-    cvSetIdentity( kalman->measurement_noise_cov );
-
-    kalman->error_cov_pre = cvCreateMat( DP, DP, CV_32FC1 );
-
-    kalman->error_cov_post = cvCreateMat( DP, DP, CV_32FC1 );
-    cvZero( kalman->error_cov_post );
-
-    kalman->gain = cvCreateMat( DP, MP, CV_32FC1 );
-
-    if( CP > 0 )
-    {
-        kalman->control_matrix = cvCreateMat( DP, CP, CV_32FC1 );
-        cvZero( kalman->control_matrix );
-    }
-
-    kalman->temp1 = cvCreateMat( DP, DP, CV_32FC1 );
-    kalman->temp2 = cvCreateMat( MP, DP, CV_32FC1 );
-    kalman->temp3 = cvCreateMat( MP, MP, CV_32FC1 );
-    kalman->temp4 = cvCreateMat( MP, DP, CV_32FC1 );
-    kalman->temp5 = cvCreateMat( MP, 1, CV_32FC1 );
-
-#if 1
-    kalman->PosterState = kalman->state_pre->data.fl;
-    kalman->PriorState = kalman->state_post->data.fl;
-    kalman->DynamMatr = kalman->transition_matrix->data.fl;
-    kalman->MeasurementMatr = kalman->measurement_matrix->data.fl;
-    kalman->MNCovariance = kalman->measurement_noise_cov->data.fl;
-    kalman->PNCovariance = kalman->process_noise_cov->data.fl;
-    kalman->KalmGainMatr = kalman->gain->data.fl;
-    kalman->PriorErrorCovariance = kalman->error_cov_pre->data.fl;
-    kalman->PosterErrorCovariance = kalman->error_cov_post->data.fl;
-#endif
-
-    return kalman;
-}
-
-
-CV_IMPL void
-cvReleaseKalman( CvKalman** _kalman )
-{
-    CvKalman *kalman;
-
-    if( !_kalman )
-        CV_Error( CV_StsNullPtr, "" );
-
-    kalman = *_kalman;
-    if( !kalman )
-        return;
-
-    /* freeing the memory */
-    cvReleaseMat( &kalman->state_pre );
-    cvReleaseMat( &kalman->state_post );
-    cvReleaseMat( &kalman->transition_matrix );
-    cvReleaseMat( &kalman->control_matrix );
-    cvReleaseMat( &kalman->measurement_matrix );
-    cvReleaseMat( &kalman->process_noise_cov );
-    cvReleaseMat( &kalman->measurement_noise_cov );
-    cvReleaseMat( &kalman->error_cov_pre );
-    cvReleaseMat( &kalman->gain );
-    cvReleaseMat( &kalman->error_cov_post );
-    cvReleaseMat( &kalman->temp1 );
-    cvReleaseMat( &kalman->temp2 );
-    cvReleaseMat( &kalman->temp3 );
-    cvReleaseMat( &kalman->temp4 );
-    cvReleaseMat( &kalman->temp5 );
-
-    memset( kalman, 0, sizeof(*kalman));
-
-    /* deallocating the structure */
-    cvFree( _kalman );
-}
-
-
-CV_IMPL const CvMat*
-cvKalmanPredict( CvKalman* kalman, const CvMat* control )
-{
-    if( !kalman )
-        CV_Error( CV_StsNullPtr, "" );
-
-    /* update the state */
-    /* x'(k) = A*x(k) */
-    cvMatMulAdd( kalman->transition_matrix, kalman->state_post, 0, kalman->state_pre );
-
-    if( control && kalman->CP > 0 )
-        /* x'(k) = x'(k) + B*u(k) */
-        cvMatMulAdd( kalman->control_matrix, control, kalman->state_pre, kalman->state_pre );
-
-    /* update error covariance matrices */
-    /* temp1 = A*P(k) */
-    cvMatMulAdd( kalman->transition_matrix, kalman->error_cov_post, 0, kalman->temp1 );
-
-    /* P'(k) = temp1*At + Q */
-    cvGEMM( kalman->temp1, kalman->transition_matrix, 1, kalman->process_noise_cov, 1,
-                     kalman->error_cov_pre, CV_GEMM_B_T );
-
-    /* handle the case when there will be measurement before the next predict */
-    cvCopy(kalman->state_pre, kalman->state_post);
-
-    return kalman->state_pre;
-}
-
-
-CV_IMPL const CvMat*
-cvKalmanCorrect( CvKalman* kalman, const CvMat* measurement )
-{
-    if( !kalman || !measurement )
-        CV_Error( CV_StsNullPtr, "" );
-
-    /* temp2 = H*P'(k) */
-    cvMatMulAdd( kalman->measurement_matrix, kalman->error_cov_pre, 0, kalman->temp2 );
-    /* temp3 = temp2*Ht + R */
-    cvGEMM( kalman->temp2, kalman->measurement_matrix, 1,
-            kalman->measurement_noise_cov, 1, kalman->temp3, CV_GEMM_B_T );
-
-    /* temp4 = inv(temp3)*temp2 = Kt(k) */
-    cvSolve( kalman->temp3, kalman->temp2, kalman->temp4, CV_SVD );
-
-    /* K(k) */
-    cvTranspose( kalman->temp4, kalman->gain );
-
-    /* temp5 = z(k) - H*x'(k) */
-    cvGEMM( kalman->measurement_matrix, kalman->state_pre, -1, measurement, 1, kalman->temp5 );
-
-    /* x(k) = x'(k) + K(k)*temp5 */
-    cvMatMulAdd( kalman->gain, kalman->temp5, kalman->state_pre, kalman->state_post );
-
-    /* P(k) = P'(k) - K(k)*temp2 */
-    cvGEMM( kalman->gain, kalman->temp2, -1, kalman->error_cov_pre, 1,
-                     kalman->error_cov_post, 0 );
-
-    return kalman->state_post;
-}
-
 namespace cv
 {
 

modules/video/src/optflowgf.cpp

@@ -644,18 +644,3 @@ void cv::calcOpticalFlowFarneback( InputArray _prev0, InputArray _next0,
         prevFlow = flow;
     }
 }
-
-
-CV_IMPL void cvCalcOpticalFlowFarneback(
-            const CvArr* _prev, const CvArr* _next,
-            CvArr* _flow, double pyr_scale, int levels,
-            int winsize, int iterations, int poly_n,
-            double poly_sigma, int flags )
-{
-    cv::Mat prev = cv::cvarrToMat(_prev), next = cv::cvarrToMat(_next);
-    cv::Mat flow = cv::cvarrToMat(_flow);
-    CV_Assert( flow.size() == prev.size() && flow.type() == CV_32FC2 );
-    cv::calcOpticalFlowFarneback( prev, next, flow, pyr_scale, levels,
-        winsize, iterations, poly_n, poly_sigma, flags );
-}
-

modules/video/src/simpleflow.cpp

@@ -41,7 +41,6 @@
 //M*/
 
 #include "precomp.hpp"
-#include "simpleflow.hpp"
 
 //
 // 2D dense optical flow algorithm from the following paper:
@@ -54,6 +53,39 @@
 namespace cv
 {
 
+static const uchar MASK_TRUE_VALUE = (uchar)255;
+
+inline static float dist(const Vec3b& p1, const Vec3b& p2) {
+  return (float)((p1[0] - p2[0]) * (p1[0] - p2[0]) +
+         (p1[1] - p2[1]) * (p1[1] - p2[1]) +
+         (p1[2] - p2[2]) * (p1[2] - p2[2]));
+}
+
+inline static float dist(const Vec2f& p1, const Vec2f& p2) {
+  return (p1[0] - p2[0]) * (p1[0] - p2[0]) +
+         (p1[1] - p2[1]) * (p1[1] - p2[1]);
+}
+
+inline static float dist(const Point2f& p1, const Point2f& p2) {
+  return (p1.x - p2.x) * (p1.x - p2.x) +
+         (p1.y - p2.y) * (p1.y - p2.y);
+}
+
+inline static float dist(float x1, float y1, float x2, float y2) {
+  return (x1 - x2) * (x1 - x2) +
+         (y1 - y2) * (y1 - y2);
+}
+
+inline static int dist(int x1, int y1, int x2, int y2) {
+  return (x1 - x2) * (x1 - x2) +
+         (y1 - y2) * (y1 - y2);
+}
+
+template<class T>
+inline static T min(T t1, T t2, T t3) {
+  return (t1 <= t2 && t1 <= t3) ? t1 : min(t2, t3);
+}
+
 static void removeOcclusions(const Mat& flow,
                              const Mat& flow_inv,
                              float occ_thr,

modules/video/src/video_init.cpp

@@ -46,50 +46,9 @@
 namespace cv
 {
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-CV_INIT_ALGORITHM(BackgroundSubtractorMOG, "BackgroundSubtractor.MOG",
-    obj.info()->addParam(obj, "history", obj.history);
-    obj.info()->addParam(obj, "nmixtures", obj.nmixtures);
-    obj.info()->addParam(obj, "backgroundRatio", obj.backgroundRatio);
-    obj.info()->addParam(obj, "noiseSigma", obj.noiseSigma));
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-CV_INIT_ALGORITHM(BackgroundSubtractorMOG2, "BackgroundSubtractor.MOG2",
-    obj.info()->addParam(obj, "history", obj.history);
-    obj.info()->addParam(obj, "nmixtures", obj.nmixtures);
-    obj.info()->addParam(obj, "varThreshold", obj.varThreshold);
-    obj.info()->addParam(obj, "detectShadows", obj.bShadowDetection));
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-CV_INIT_ALGORITHM(BackgroundSubtractorGMG, "BackgroundSubtractor.GMG",
-                  obj.info()->addParam(obj, "maxFeatures", obj.maxFeatures,false,0,0,
-                                       "Maximum number of features to store in histogram. Harsh enforcement of sparsity constraint.");
-                  obj.info()->addParam(obj, "learningRate", obj.learningRate,false,0,0,
-                                       "Adaptation rate of histogram. Close to 1, slow adaptation. Close to 0, fast adaptation, features forgotten quickly.");
-                  obj.info()->addParam(obj, "initializationFrames", obj.numInitializationFrames,false,0,0,
-                                       "Number of frames to use to initialize histograms of pixels.");
-                  obj.info()->addParam(obj, "quantizationLevels", obj.quantizationLevels,false,0,0,
-                                       "Number of discrete colors to be used in histograms. Up-front quantization.");
-                  obj.info()->addParam(obj, "backgroundPrior", obj.backgroundPrior,false,0,0,
-                                       "Prior probability that each individual pixel is a background pixel.");
-                  obj.info()->addParam(obj, "smoothingRadius", obj.smoothingRadius,false,0,0,
-                                       "Radius of smoothing kernel to filter noise from FG mask image.");
-                  obj.info()->addParam(obj, "decisionThreshold", obj.decisionThreshold,false,0,0,
-                                       "Threshold for FG decision rule. Pixel is FG if posterior probability exceeds threshold.");
-                  obj.info()->addParam(obj, "updateBackgroundModel", obj.updateBackgroundModel,false,0,0,
-                                       "Perform background model update."));
-
 bool initModule_video(void)
 {
-    bool all = true;
-    all &= !BackgroundSubtractorMOG_info_auto.name().empty();
-    all &= !BackgroundSubtractorMOG2_info_auto.name().empty();
-    all &= !BackgroundSubtractorGMG_info_auto.name().empty();
-
-    return all;
+    return true;
 }
 
 }

modules/video/test/test_backgroundsubtractor_gbh.cpp

@@ -37,8 +37,7 @@ void CV_BackgroundSubtractorTest::run(int)
     int width = 2 + ((unsigned int)rng)%98; //!< Mat will be 2 to 100 in width and height
     int height = 2 + ((unsigned int)rng)%98;
 
-    Ptr<BackgroundSubtractorGMG> fgbg =
-            Algorithm::create<BackgroundSubtractorGMG>("BackgroundSubtractor.GMG");
+    Ptr<BackgroundSubtractorGMG> fgbg = createBackgroundSubtractorGMG();
     Mat fgmask;
 
     if (fgbg.empty())
@@ -47,19 +46,13 @@ void CV_BackgroundSubtractorTest::run(int)
     /**
      * Set a few parameters
      */
-    fgbg->set("smoothingRadius",7);
-    fgbg->set("decisionThreshold",0.7);
-    fgbg->set("initializationFrames",120);
+    fgbg->setSmoothingRadius(7);
+    fgbg->setDecisionThreshold(0.7);
+    fgbg->setNumFrames(120);
 
     /**
      * Generate bounds for the values in the matrix for each type
      */
-    uchar maxuc = 0, minuc = 0;
-    char maxc = 0, minc = 0;
-    unsigned int maxui = 0, minui = 0;
-    int maxi=0, mini = 0;
-    long int maxli = 0, minli = 0;
-    float maxf = 0, minf = 0;
     double maxd = 0, mind = 0;
 
     /**
@@ -69,34 +62,34 @@ void CV_BackgroundSubtractorTest::run(int)
     if (type == CV_8U)
     {
         uchar half = UCHAR_MAX/2;
-        maxuc = (unsigned char)rng.uniform(half+32, UCHAR_MAX);
-        minuc = (unsigned char)rng.uniform(0, half-32);
+        maxd = (unsigned char)rng.uniform(half+32, UCHAR_MAX);
+        mind = (unsigned char)rng.uniform(0, half-32);
     }
     else if (type == CV_8S)
     {
-        maxc = (char)rng.uniform(32, CHAR_MAX);
-        minc = (char)rng.uniform(CHAR_MIN, -32);
+        maxd = (char)rng.uniform(32, CHAR_MAX);
+        mind = (char)rng.uniform(CHAR_MIN, -32);
     }
     else if (type == CV_16U)
     {
         ushort half = USHRT_MAX/2;
-        maxui = (unsigned int)rng.uniform(half+32, USHRT_MAX);
-        minui = (unsigned int)rng.uniform(0, half-32);
+        maxd = (unsigned int)rng.uniform(half+32, USHRT_MAX);
+        mind = (unsigned int)rng.uniform(0, half-32);
     }
     else if (type == CV_16S)
     {
-        maxi = rng.uniform(32, SHRT_MAX);
-        mini = rng.uniform(SHRT_MIN, -32);
+        maxd = rng.uniform(32, SHRT_MAX);
+        mind = rng.uniform(SHRT_MIN, -32);
     }
     else if (type == CV_32S)
     {
-        maxli = rng.uniform(32, INT_MAX);
-        minli = rng.uniform(INT_MIN, -32);
+        maxd = rng.uniform(32, INT_MAX);
+        mind = rng.uniform(INT_MIN, -32);
     }
     else if (type == CV_32F)
     {
-        maxf = rng.uniform(32.0f, FLT_MAX);
-        minf = rng.uniform(-FLT_MAX, -32.0f);
+        maxd = rng.uniform(32.0f, FLT_MAX);
+        mind = rng.uniform(-FLT_MAX, -32.0f);
     }
     else if (type == CV_64F)
     {
@@ -104,60 +97,22 @@ void CV_BackgroundSubtractorTest::run(int)
         mind = rng.uniform(-DBL_MAX, -32.0);
     }
 
+    fgbg->setMinVal(mind);
+    fgbg->setMaxVal(maxd);
+
     Mat simImage = Mat::zeros(height, width, channelsAndType);
-    const unsigned int numLearningFrames = 120;
-    for (unsigned int i = 0; i < numLearningFrames; ++i)
+    int numLearningFrames = 120;
+    for (int i = 0; i < numLearningFrames; ++i)
     {
         /**
          * Genrate simulated "image" for any type. Values always confined to upper half of range.
          */
-        if (type == CV_8U)
-        {
-            rng.fill(simImage,RNG::UNIFORM,(unsigned char)(minuc/2+maxuc/2),maxuc);
-            if (i == 0)
-                fgbg->initialize(simImage.size(),minuc,maxuc);
-        }
-        else if (type == CV_8S)
-        {
-            rng.fill(simImage,RNG::UNIFORM,(char)(minc/2+maxc/2),maxc);
-            if (i==0)
-                fgbg->initialize(simImage.size(),minc,maxc);
-        }
-        else if (type == CV_16U)
-        {
-            rng.fill(simImage,RNG::UNIFORM,(unsigned int)(minui/2+maxui/2),maxui);
-            if (i==0)
-                fgbg->initialize(simImage.size(),minui,maxui);
-        }
-        else if (type == CV_16S)
-        {
-            rng.fill(simImage,RNG::UNIFORM,(int)(mini/2+maxi/2),maxi);
-            if (i==0)
-                fgbg->initialize(simImage.size(),mini,maxi);
-        }
-        else if (type == CV_32F)
-        {
-            rng.fill(simImage,RNG::UNIFORM,(float)(minf/2.0+maxf/2.0),maxf);
-            if (i==0)
-                fgbg->initialize(simImage.size(),minf,maxf);
-        }
-        else if (type == CV_32S)
-        {
-            rng.fill(simImage,RNG::UNIFORM,(long int)(minli/2+maxli/2),maxli);
-            if (i==0)
-                fgbg->initialize(simImage.size(),minli,maxli);
-        }
-        else if (type == CV_64F)
-        {
-            rng.fill(simImage,RNG::UNIFORM,(double)(mind/2.0+maxd/2.0),maxd);
-            if (i==0)
-                fgbg->initialize(simImage.size(),mind,maxd);
-        }
+        rng.fill(simImage, RNG::UNIFORM, (mind + maxd)*0.5, maxd);
 
         /**
          * Feed simulated images into background subtractor
          */
-        (*fgbg)(simImage,fgmask);
+        fgbg->apply(simImage,fgmask);
         Mat fullbg = Mat::zeros(simImage.rows, simImage.cols, CV_8U);
 
         //! fgmask should be entirely background during training
@@ -166,22 +121,9 @@ void CV_BackgroundSubtractorTest::run(int)
             ts->set_failed_test_info( code );
     }
     //! generate last image, distinct from training images
-    if (type == CV_8U)
-        rng.fill(simImage,RNG::UNIFORM,minuc,minuc);
-    else if (type == CV_8S)
-        rng.fill(simImage,RNG::UNIFORM,minc,minc);
-    else if (type == CV_16U)
-        rng.fill(simImage,RNG::UNIFORM,minui,minui);
-    else if (type == CV_16S)
-        rng.fill(simImage,RNG::UNIFORM,mini,mini);
-    else if (type == CV_32F)
-        rng.fill(simImage,RNG::UNIFORM,minf,minf);
-    else if (type == CV_32S)
-        rng.fill(simImage,RNG::UNIFORM,minli,minli);
-    else if (type == CV_64F)
-        rng.fill(simImage,RNG::UNIFORM,mind,mind);
+    rng.fill(simImage, RNG::UNIFORM, mind, maxd);
 
-    (*fgbg)(simImage,fgmask);
+    fgbg->apply(simImage,fgmask);
     //! now fgmask should be entirely foreground
     Mat fullfg = 255*Mat::ones(simImage.rows, simImage.cols, CV_8U);
     code = cvtest::cmpEps2( ts, fgmask, fullfg, 255, false, "The final foreground mask" );

modules/video/test/test_estimaterigid.cpp

@@ -153,7 +153,7 @@ bool CV_RigidTransform_Test::testImage()
 
     Mat aff_est = estimateRigidTransform(img, rotated, true);
 
-    const double thres = 0.03;
+    const double thres = 0.033;
     if (norm(aff_est, aff, NORM_INF) > thres)
     {
         ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);

samples/cpp/bgfg_gmg.cpp

@@ -32,16 +32,13 @@ int main(int argc, char** argv)
     setUseOptimized(true);
     setNumThreads(8);
 
-    Ptr<BackgroundSubtractorGMG> fgbg = Algorithm::create<BackgroundSubtractorGMG>("BackgroundSubtractor.GMG");
+    Ptr<BackgroundSubtractor> fgbg = createBackgroundSubtractorGMG(20, 0.7);
     if (fgbg.empty())
     {
         std::cerr << "Failed to create BackgroundSubtractor.GMG Algorithm." << std::endl;
         return -1;
     }
 
-    fgbg->set("initializationFrames", 20);
-    fgbg->set("decisionThreshold", 0.7);
-
     VideoCapture cap;
     if (argc > 1)
         cap.open(argv[1]);
@@ -65,9 +62,9 @@ int main(int argc, char** argv)
         if (frame.empty())
             break;
 
-        (*fgbg)(frame, fgmask);
+        fgbg->apply(frame, fgmask);
 
-        frame.copyTo(segm);
+        frame.convertTo(segm, CV_8U, 0.5);
         add(frame, Scalar(100, 100, 0), segm, fgmask);
 
         imshow("FG Segmentation", segm);

samples/cpp/bgfg_segm.cpp

@@ -51,7 +51,7 @@ int main(int argc, const char** argv)
     namedWindow("foreground image", CV_WINDOW_NORMAL);
     namedWindow("mean background image", CV_WINDOW_NORMAL);
 
-    BackgroundSubtractorMOG2 bg_model;//(100, 3, 0.3, 5);
+    Ptr<BackgroundSubtractor> bg_model = createBackgroundSubtractorMOG2();
 
     Mat img, fgmask, fgimg;
 
@@ -68,13 +68,13 @@ int main(int argc, const char** argv)
           fgimg.create(img.size(), img.type());
 
         //update the model
-        bg_model(img, fgmask, update_bg_model ? -1 : 0);
+        bg_model->apply(img, fgmask, update_bg_model ? -1 : 0);
 
         fgimg = Scalar::all(0);
         img.copyTo(fgimg, fgmask);
 
         Mat bgimg;
-        bg_model.getBackgroundImage(bgimg);
+        bg_model->getBackgroundImage(bgimg);
 
         imshow("image", img);
         imshow("foreground mask", fgmask);

samples/cpp/segment_objects.cpp

@@ -87,15 +87,15 @@ int main(int argc, char** argv)
     namedWindow("video", 1);
     namedWindow("segmented", 1);
 
-    BackgroundSubtractorMOG bgsubtractor;
-    bgsubtractor.set("noiseSigma", 10);
+    Ptr<BackgroundSubtractorMOG> bgsubtractor=createBackgroundSubtractorMOG();
+    bgsubtractor->setNoiseSigma(10);
 
     for(;;)
     {
         cap >> tmp_frame;
         if( !tmp_frame.data )
             break;
-        bgsubtractor(tmp_frame, bgmask, update_bg_model ? -1 : 0);
+        bgsubtractor->apply(tmp_frame, bgmask, update_bg_model ? -1 : 0);
         //CvMat _bgmask = bgmask;
         //cvSegmentFGMask(&_bgmask);
         refineSegments(tmp_frame, bgmask, out_frame);

samples/gpu/performance/tests.cpp

@@ -1316,10 +1316,10 @@ TEST(MOG)
     cv::Mat frame;
     cap >> frame;
 
-    cv::BackgroundSubtractorMOG mog;
+    cv::Ptr<cv::BackgroundSubtractor> mog = cv::createBackgroundSubtractorMOG();
     cv::Mat foreground;
 
-    mog(frame, foreground, 0.01);
+    mog->apply(frame, foreground, 0.01);
 
     while (!TestSystem::instance().stop())
     {
@@ -1327,7 +1327,7 @@ TEST(MOG)
 
         TestSystem::instance().cpuOn();
 
-        mog(frame, foreground, 0.01);
+        mog->apply(frame, foreground, 0.01);
 
         TestSystem::instance().cpuOff();
     }
@@ -1367,12 +1367,12 @@ TEST(MOG2)
     cv::Mat frame;
     cap >> frame;
 
-    cv::BackgroundSubtractorMOG2 mog2;
+    cv::Ptr<cv::BackgroundSubtractor> mog2 = cv::createBackgroundSubtractorMOG2();
     cv::Mat foreground;
     cv::Mat background;
 
-    mog2(frame, foreground);
-    mog2.getBackgroundImage(background);
+    mog2->apply(frame, foreground);
+    mog2->getBackgroundImage(background);
 
     while (!TestSystem::instance().stop())
     {
@@ -1380,8 +1380,8 @@ TEST(MOG2)
 
         TestSystem::instance().cpuOn();
 
-        mog2(frame, foreground);
-        mog2.getBackgroundImage(background);
+        mog2->apply(frame, foreground);
+        mog2->getBackgroundImage(background);
 
         TestSystem::instance().cpuOff();
     }