mirror of
https://github.com/opencv/opencv.git
synced 2025-01-03 07:58:00 +08:00
455 lines
18 KiB
C++
455 lines
18 KiB
C++
/*M///////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
//
|
|
// By downloading, copying, installing or using the software you agree to this license.
|
|
// If you do not agree to this license, do not download, install,
|
|
// copy or use the software.
|
|
//
|
|
//
|
|
// License Agreement
|
|
// For Open Source Computer Vision Library
|
|
//
|
|
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
|
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
|
// Third party copyrights are property of their respective owners.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistribution's of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// * Redistribution's in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// * 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
|
|
// any express or implied warranties, including, but not limited to, the implied
|
|
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
|
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
|
// indirect, incidental, special, exemplary, or consequential damages
|
|
// (including, but not limited to, procurement of substitute goods or services;
|
|
// loss of use, data, or profits; or business interruption) however caused
|
|
// and on any theory of liability, whether in contract, strict liability,
|
|
// or tort (including negligence or otherwise) arising in any way out of
|
|
// the use of this software, even if advised of the possibility of such damage.
|
|
//
|
|
//M*/
|
|
|
|
#ifndef __OPENCV_BACKGROUND_SEGM_HPP__
|
|
#define __OPENCV_BACKGROUND_SEGM_HPP__
|
|
|
|
#include "opencv2/core/core.hpp"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/****************************************************************************************\
|
|
* Background/foreground segmentation *
|
|
\****************************************************************************************/
|
|
|
|
/* We discriminate between foreground and background pixels
|
|
* by building and maintaining a model of the background.
|
|
* Any pixel which does not fit this model is then deemed
|
|
* to be foreground.
|
|
*
|
|
* At present we support two core background models,
|
|
* one of which has two variations:
|
|
*
|
|
* o CV_BG_MODEL_FGD: latest and greatest algorithm, described in
|
|
*
|
|
* Foreground Object Detection from Videos Containing Complex Background.
|
|
* Liyuan Li, Weimin Huang, Irene Y.H. Gu, and Qi Tian.
|
|
* ACM MM2003 9p
|
|
*
|
|
* o CV_BG_MODEL_FGD_SIMPLE:
|
|
* A code comment describes this as a simplified version of the above,
|
|
* but the code is in fact currently identical
|
|
*
|
|
* o CV_BG_MODEL_MOG: "Mixture of Gaussians", older algorithm, described in
|
|
*
|
|
* Moving target classification and tracking from real-time video.
|
|
* A Lipton, H Fujijoshi, R Patil
|
|
* Proceedings IEEE Workshop on Application of Computer Vision pp 8-14 1998
|
|
*
|
|
* Learning patterns of activity using real-time tracking
|
|
* C Stauffer and W Grimson August 2000
|
|
* IEEE Transactions on Pattern Analysis and Machine Intelligence 22(8):747-757
|
|
*/
|
|
|
|
|
|
#define CV_BG_MODEL_FGD 0
|
|
#define CV_BG_MODEL_MOG 1 /* "Mixture of Gaussians". */
|
|
#define CV_BG_MODEL_FGD_SIMPLE 2
|
|
|
|
struct CvBGStatModel;
|
|
|
|
typedef void (CV_CDECL * CvReleaseBGStatModel)( struct CvBGStatModel** bg_model );
|
|
typedef int (CV_CDECL * CvUpdateBGStatModel)( IplImage* curr_frame, struct CvBGStatModel* bg_model,
|
|
double learningRate );
|
|
|
|
#define CV_BG_STAT_MODEL_FIELDS() \
|
|
int type; /*type of BG model*/ \
|
|
CvReleaseBGStatModel release; \
|
|
CvUpdateBGStatModel update; \
|
|
IplImage* background; /*8UC3 reference background image*/ \
|
|
IplImage* foreground; /*8UC1 foreground image*/ \
|
|
IplImage** layers; /*8UC3 reference background image, can be null */ \
|
|
int layer_count; /* can be zero */ \
|
|
CvMemStorage* storage; /*storage for foreground_regions*/ \
|
|
CvSeq* foreground_regions /*foreground object contours*/
|
|
|
|
typedef struct CvBGStatModel
|
|
{
|
|
CV_BG_STAT_MODEL_FIELDS();
|
|
} CvBGStatModel;
|
|
|
|
//
|
|
|
|
// Releases memory used by BGStatModel
|
|
CVAPI(void) cvReleaseBGStatModel( CvBGStatModel** bg_model );
|
|
|
|
// Updates statistical model and returns number of found foreground regions
|
|
CVAPI(int) cvUpdateBGStatModel( IplImage* current_frame, CvBGStatModel* bg_model,
|
|
double learningRate CV_DEFAULT(-1));
|
|
|
|
// Performs FG post-processing using segmentation
|
|
// (all pixels of a region will be classified as foreground if majority of pixels of the region are FG).
|
|
// parameters:
|
|
// segments - pointer to result of segmentation (for example MeanShiftSegmentation)
|
|
// bg_model - pointer to CvBGStatModel structure
|
|
CVAPI(void) cvRefineForegroundMaskBySegm( CvSeq* segments, CvBGStatModel* bg_model );
|
|
|
|
/* Common use change detection function */
|
|
CVAPI(int) cvChangeDetection( IplImage* prev_frame,
|
|
IplImage* curr_frame,
|
|
IplImage* change_mask );
|
|
|
|
/*
|
|
Interface of ACM MM2003 algorithm
|
|
*/
|
|
|
|
/* Default parameters of foreground detection algorithm: */
|
|
#define CV_BGFG_FGD_LC 128
|
|
#define CV_BGFG_FGD_N1C 15
|
|
#define CV_BGFG_FGD_N2C 25
|
|
|
|
#define CV_BGFG_FGD_LCC 64
|
|
#define CV_BGFG_FGD_N1CC 25
|
|
#define CV_BGFG_FGD_N2CC 40
|
|
|
|
/* Background reference image update parameter: */
|
|
#define CV_BGFG_FGD_ALPHA_1 0.1f
|
|
|
|
/* stat model update parameter
|
|
* 0.002f ~ 1K frame(~45sec), 0.005 ~ 18sec (if 25fps and absolutely static BG)
|
|
*/
|
|
#define CV_BGFG_FGD_ALPHA_2 0.005f
|
|
|
|
/* start value for alpha parameter (to fast initiate statistic model) */
|
|
#define CV_BGFG_FGD_ALPHA_3 0.1f
|
|
|
|
#define CV_BGFG_FGD_DELTA 2
|
|
|
|
#define CV_BGFG_FGD_T 0.9f
|
|
|
|
#define CV_BGFG_FGD_MINAREA 15.f
|
|
|
|
#define CV_BGFG_FGD_BG_UPDATE_TRESH 0.5f
|
|
|
|
/* See the above-referenced Li/Huang/Gu/Tian paper
|
|
* for a full description of these background-model
|
|
* tuning parameters.
|
|
*
|
|
* Nomenclature: 'c' == "color", a three-component red/green/blue vector.
|
|
* We use histograms of these to model the range of
|
|
* colors we've seen at a given background pixel.
|
|
*
|
|
* 'cc' == "color co-occurrence", a six-component vector giving
|
|
* RGB color for both this frame and preceding frame.
|
|
* We use histograms of these to model the range of
|
|
* color CHANGES we've seen at a given background pixel.
|
|
*/
|
|
typedef struct CvFGDStatModelParams
|
|
{
|
|
int Lc; /* Quantized levels per 'color' component. Power of two, typically 32, 64 or 128. */
|
|
int N1c; /* Number of color vectors used to model normal background color variation at a given pixel. */
|
|
int N2c; /* Number of color vectors retained at given pixel. Must be > N1c, typically ~ 5/3 of N1c. */
|
|
/* Used to allow the first N1c vectors to adapt over time to changing background. */
|
|
|
|
int Lcc; /* Quantized levels per 'color co-occurrence' component. Power of two, typically 16, 32 or 64. */
|
|
int N1cc; /* Number of color co-occurrence vectors used to model normal background color variation at a given pixel. */
|
|
int N2cc; /* Number of color co-occurrence vectors retained at given pixel. Must be > N1cc, typically ~ 5/3 of N1cc. */
|
|
/* Used to allow the first N1cc vectors to adapt over time to changing background. */
|
|
|
|
int is_obj_without_holes;/* If TRUE we ignore holes within foreground blobs. Defaults to TRUE. */
|
|
int perform_morphing; /* Number of erode-dilate-erode foreground-blob cleanup iterations. */
|
|
/* These erase one-pixel junk blobs and merge almost-touching blobs. Default value is 1. */
|
|
|
|
float alpha1; /* How quickly we forget old background pixel values seen. Typically set to 0.1 */
|
|
float alpha2; /* "Controls speed of feature learning". Depends on T. Typical value circa 0.005. */
|
|
float alpha3; /* Alternate to alpha2, used (e.g.) for quicker initial convergence. Typical value 0.1. */
|
|
|
|
float delta; /* Affects color and color co-occurrence quantization, typically set to 2. */
|
|
float T; /* "A percentage value which determines when new features can be recognized as new background." (Typically 0.9).*/
|
|
float minArea; /* Discard foreground blobs whose bounding box is smaller than this threshold. */
|
|
} CvFGDStatModelParams;
|
|
|
|
typedef struct CvBGPixelCStatTable
|
|
{
|
|
float Pv, Pvb;
|
|
uchar v[3];
|
|
} CvBGPixelCStatTable;
|
|
|
|
typedef struct CvBGPixelCCStatTable
|
|
{
|
|
float Pv, Pvb;
|
|
uchar v[6];
|
|
} CvBGPixelCCStatTable;
|
|
|
|
typedef struct CvBGPixelStat
|
|
{
|
|
float Pbc;
|
|
float Pbcc;
|
|
CvBGPixelCStatTable* ctable;
|
|
CvBGPixelCCStatTable* cctable;
|
|
uchar is_trained_st_model;
|
|
uchar is_trained_dyn_model;
|
|
} CvBGPixelStat;
|
|
|
|
|
|
typedef struct CvFGDStatModel
|
|
{
|
|
CV_BG_STAT_MODEL_FIELDS();
|
|
CvBGPixelStat* pixel_stat;
|
|
IplImage* Ftd;
|
|
IplImage* Fbd;
|
|
IplImage* prev_frame;
|
|
CvFGDStatModelParams params;
|
|
} CvFGDStatModel;
|
|
|
|
/* Creates FGD model */
|
|
CVAPI(CvBGStatModel*) cvCreateFGDStatModel( IplImage* first_frame,
|
|
CvFGDStatModelParams* parameters CV_DEFAULT(NULL));
|
|
|
|
/*
|
|
Interface of Gaussian mixture algorithm
|
|
|
|
"An improved adaptive background mixture model for real-time tracking with shadow detection"
|
|
P. KadewTraKuPong and R. Bowden,
|
|
Proc. 2nd European Workshp on Advanced Video-Based Surveillance Systems, 2001."
|
|
http://personal.ee.surrey.ac.uk/Personal/R.Bowden/publications/avbs01/avbs01.pdf
|
|
*/
|
|
|
|
/* Note: "MOG" == "Mixture Of Gaussians": */
|
|
|
|
#define CV_BGFG_MOG_MAX_NGAUSSIANS 500
|
|
|
|
/* default parameters of gaussian background detection algorithm */
|
|
#define CV_BGFG_MOG_BACKGROUND_THRESHOLD 0.7 /* threshold sum of weights for background test */
|
|
#define CV_BGFG_MOG_STD_THRESHOLD 2.5 /* lambda=2.5 is 99% */
|
|
#define CV_BGFG_MOG_WINDOW_SIZE 200 /* Learning rate; alpha = 1/CV_GBG_WINDOW_SIZE */
|
|
#define CV_BGFG_MOG_NGAUSSIANS 5 /* = K = number of Gaussians in mixture */
|
|
#define CV_BGFG_MOG_WEIGHT_INIT 0.05
|
|
#define CV_BGFG_MOG_SIGMA_INIT 30
|
|
#define CV_BGFG_MOG_MINAREA 15.f
|
|
|
|
|
|
#define CV_BGFG_MOG_NCOLORS 3
|
|
|
|
typedef struct CvGaussBGStatModelParams
|
|
{
|
|
int win_size; /* = 1/alpha */
|
|
int n_gauss;
|
|
double bg_threshold, std_threshold, minArea;
|
|
double weight_init, variance_init;
|
|
}CvGaussBGStatModelParams;
|
|
|
|
typedef struct CvGaussBGValues
|
|
{
|
|
int match_sum;
|
|
double weight;
|
|
double variance[CV_BGFG_MOG_NCOLORS];
|
|
double mean[CV_BGFG_MOG_NCOLORS];
|
|
} CvGaussBGValues;
|
|
|
|
typedef struct CvGaussBGPoint
|
|
{
|
|
CvGaussBGValues* g_values;
|
|
} CvGaussBGPoint;
|
|
|
|
|
|
typedef struct CvGaussBGModel
|
|
{
|
|
CV_BG_STAT_MODEL_FIELDS();
|
|
CvGaussBGStatModelParams params;
|
|
CvGaussBGPoint* g_point;
|
|
int countFrames;
|
|
} CvGaussBGModel;
|
|
|
|
|
|
/* Creates Gaussian mixture background model */
|
|
CVAPI(CvBGStatModel*) cvCreateGaussianBGModel( IplImage* first_frame,
|
|
CvGaussBGStatModelParams* parameters CV_DEFAULT(NULL));
|
|
|
|
|
|
typedef struct CvBGCodeBookElem
|
|
{
|
|
struct CvBGCodeBookElem* next;
|
|
int tLastUpdate;
|
|
int stale;
|
|
uchar boxMin[3];
|
|
uchar boxMax[3];
|
|
uchar learnMin[3];
|
|
uchar learnMax[3];
|
|
} CvBGCodeBookElem;
|
|
|
|
typedef struct CvBGCodeBookModel
|
|
{
|
|
CvSize size;
|
|
int t;
|
|
uchar cbBounds[3];
|
|
uchar modMin[3];
|
|
uchar modMax[3];
|
|
CvBGCodeBookElem** cbmap;
|
|
CvMemStorage* storage;
|
|
CvBGCodeBookElem* freeList;
|
|
} CvBGCodeBookModel;
|
|
|
|
CVAPI(CvBGCodeBookModel*) cvCreateBGCodeBookModel();
|
|
CVAPI(void) cvReleaseBGCodeBookModel( CvBGCodeBookModel** model );
|
|
|
|
CVAPI(void) cvBGCodeBookUpdate( CvBGCodeBookModel* model, const CvArr* image,
|
|
CvRect roi CV_DEFAULT(cvRect(0,0,0,0)),
|
|
const CvArr* mask CV_DEFAULT(0) );
|
|
|
|
CVAPI(int) cvBGCodeBookDiff( const CvBGCodeBookModel* model, const CvArr* image,
|
|
CvArr* fgmask, CvRect roi CV_DEFAULT(cvRect(0,0,0,0)) );
|
|
|
|
CVAPI(void) cvBGCodeBookClearStale( CvBGCodeBookModel* model, int staleThresh,
|
|
CvRect roi CV_DEFAULT(cvRect(0,0,0,0)),
|
|
const CvArr* mask CV_DEFAULT(0) );
|
|
|
|
CVAPI(CvSeq*) cvSegmentFGMask( CvArr *fgmask, int poly1Hull0 CV_DEFAULT(1),
|
|
float perimScale CV_DEFAULT(4.f),
|
|
CvMemStorage* storage CV_DEFAULT(0),
|
|
CvPoint offset CV_DEFAULT(cvPoint(0,0)));
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
|
|
namespace cv
|
|
{
|
|
|
|
/*!
|
|
The Base Class for Background/Foreground Segmentation
|
|
|
|
The class is only used to define the common interface for
|
|
the whole family of background/foreground segmentation algorithms.
|
|
*/
|
|
class CV_EXPORTS_W BackgroundSubtractor
|
|
{
|
|
public:
|
|
//! the virtual destructor
|
|
virtual ~BackgroundSubtractor();
|
|
//! the update operator that takes the next video frame and returns the current foreground mask as 8-bit binary image.
|
|
CV_WRAP_AS(apply) virtual void operator()(const Mat& image, CV_OUT Mat& fgmask,
|
|
double learningRate=0);
|
|
};
|
|
|
|
|
|
/*!
|
|
Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm
|
|
|
|
The class implements the following algorithm:
|
|
"An improved adaptive background mixture model for real-time tracking with shadow detection"
|
|
P. KadewTraKuPong and R. Bowden,
|
|
Proc. 2nd European Workshp on Advanced Video-Based Surveillance Systems, 2001."
|
|
http://personal.ee.surrey.ac.uk/Personal/R.Bowden/publications/avbs01/avbs01.pdf
|
|
|
|
*/
|
|
class CV_EXPORTS_W BackgroundSubtractorMOG : public BackgroundSubtractor
|
|
{
|
|
public:
|
|
//! the default constructor
|
|
CV_WRAP BackgroundSubtractorMOG();
|
|
//! the full constructor that takes the length of the history, the number of gaussian mixtures, the background ratio parameter and the noise strength
|
|
CV_WRAP BackgroundSubtractorMOG(int history, int nmixtures, double backgroundRatio, double noiseSigma=0);
|
|
//! the destructor
|
|
virtual ~BackgroundSubtractorMOG();
|
|
//! the update operator
|
|
virtual void operator()(const Mat& image, Mat& fgmask, double learningRate=0);
|
|
|
|
//! re-initiaization method
|
|
virtual void initialize(Size frameSize, int frameType);
|
|
|
|
Size frameSize;
|
|
int frameType;
|
|
Mat bgmodel;
|
|
int nframes;
|
|
int history;
|
|
int nmixtures;
|
|
double varThreshold;
|
|
double backgroundRatio;
|
|
double noiseSigma;
|
|
};
|
|
|
|
|
|
class CV_EXPORTS_W BackgroundSubtractorMOG2 : public BackgroundSubtractor
|
|
{
|
|
public:
|
|
//! the default constructor
|
|
CV_WRAP BackgroundSubtractorMOG2();
|
|
//! the full constructor that takes the length of the history, the number of gaussian mixtures, the background ratio parameter and the noise strength
|
|
CV_WRAP BackgroundSubtractorMOG2(double alphaT,
|
|
double sigma=15,
|
|
int nmixtures=5,
|
|
bool postFiltering=false,
|
|
double minArea=15,
|
|
bool detectShadows=true,
|
|
bool removeForeground=false,
|
|
|
|
double Tb=16,
|
|
double Tg=9,
|
|
double TB=0.9,
|
|
double CT=0.05,
|
|
|
|
int shadowOutputValue=127,
|
|
double tau=0.5);
|
|
|
|
//! the destructor
|
|
virtual ~BackgroundSubtractorMOG2();
|
|
//! the update operator
|
|
virtual void operator()(const Mat& image, Mat& fgmask, double learningRate=0);
|
|
|
|
//! re-initiaization method
|
|
virtual void initialize(Size frameSize,
|
|
double alphaT,
|
|
double sigma=15,
|
|
int nmixtures=5,
|
|
bool postFiltering=false,
|
|
double minArea=15,
|
|
bool detectShadows=true,
|
|
bool removeForeground=false,
|
|
|
|
double Tb=16,
|
|
double Tg=9,
|
|
double TB=0.9,
|
|
double CT=0.05,
|
|
|
|
int nShadowDetection=127,
|
|
double tau=0.5);
|
|
|
|
void* model;
|
|
};
|
|
|
|
}
|
|
#endif
|
|
|
|
#endif
|