generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Background subtractor GMG: removed flexitype, fixed build errors.

Browse Source
This commit is contained in:
Andrey Kamaev 2012-06-30 20:47:09 +00:00
parent afe11f69fb
commit dec38e5949
3 changed files with 187 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
modules/video/include/opencv2/video/background_segm.hpp
View File

@ -199,75 +199,7 @@ protected:
*/ */
class CV_EXPORTS BackgroundSubtractorGMG: public cv::BackgroundSubtractor class CV_EXPORTS BackgroundSubtractorGMG: public cv::BackgroundSubtractor
{ {
private: protected:
/**
* A general flexible datatype.
*
* Used internally to enable background subtraction algorithm to be robust to any input Mat type.
* Datatype can be char, unsigned char, int, unsigned int, long int, float, or double.
*/
union flexitype{
char c;
uchar uc;
int i;
unsigned int ui;
long int li;
float f;
double d;
flexitype(){d = 0.0;} //!< Default constructor, set all bits of the union to 0.
flexitype(char cval){c = cval;} //!< Char type constructor
bool operator ==(flexitype& rhs)
{
return d == rhs.d;
}
//! Char type assignment operator
flexitype& operator =(char cval){
if (this->c == cval){return *this;}
c = cval; return *this;
}
flexitype(unsigned char ucval){uc = ucval;} //!< unsigned char type constructor
//! unsigned char type assignment operator
flexitype& operator =(unsigned char ucval){
if (this->uc == ucval){return *this;}
uc = ucval; return *this;
}
flexitype(int ival){i = ival;} //!< int type constructor
//! int type assignment operator
flexitype& operator =(int ival){
if (this->i == ival){return *this;}
i = ival; return *this;
}
flexitype(unsigned int uival){ui = uival;} //!< unsigned int type constructor
//! unsigned int type assignment operator
flexitype& operator =(unsigned int uival){
if (this->ui == uival){return *this;}
ui = uival; return *this;
}
flexitype(float fval){f = fval;} //!< float type constructor
//! float type assignment operator
flexitype& operator =(float fval){
if (this->f == fval){return *this;}
f = fval; return *this;
}
flexitype(long int lival){li = lival;} //!< long int type constructor
//! long int type assignment operator
flexitype& operator =(long int lival){
if (this->li == lival){return *this;}
li = lival; return *this;
}
flexitype(double dval){d=dval;} //!< double type constructor
//! double type assignment operator
flexitype& operator =(double dval){
if (this->d == dval){return *this;}
d = dval; return *this;
}
};
/** /**
* Used internally to represent a single feature in a histogram. * Used internally to represent a single feature in a histogram.
* Feature is a color and an associated likelihood (weight in the histogram). * Feature is a color and an associated likelihood (weight in the histogram).
@ -387,7 +319,7 @@ public:
* @param min minimum value taken on by pixels in image sequence. Usually 0 * @param min minimum value taken on by pixels in image sequence. Usually 0
* @param max maximum value taken on by pixels in image sequence. e.g. 1.0 or 255 * @param max maximum value taken on by pixels in image sequence. e.g. 1.0 or 255
*/ */
void initializeType(InputArray image, flexitype min, flexitype max); void initializeType(InputArray image, double min, double max);
/** /**
* Selectively update the background model. Only update background model for pixels identified * Selectively update the background model. Only update background model for pixels identified
* as background. * as background.
@ -417,24 +349,20 @@ protected:
double decisionThreshold; //!< value above which pixel is determined to be FG. double decisionThreshold; //!< value above which pixel is determined to be FG.
int smoothingRadius; //!< smoothing radius, in pixels, for cleaning up FG image. int smoothingRadius; //!< smoothing radius, in pixels, for cleaning up FG image.
flexitype maxVal, minVal; double maxVal, minVal;
/* /*
* General Parameters * General Parameters
*/ */
size_t imWidth; //!< width of image. int imWidth; //!< width of image.
size_t imHeight; //!< height of image. int imHeight; //!< height of image.
size_t numPixels; size_t numPixels;
int imageDepth; //!< Depth of image, e.g. CV_8U unsigned int numChannels; //!< Number of channels in image.
unsigned int numChannels; //!< Number of channels in image.
bool isDataInitialized; bool isDataInitialized;
//!< After general parameters are set, data structures must be initialized. //!< After general parameters are set, data structures must be initialized.
size_t elemSize; //!< store image mat element sizes
size_t elemSize1;
/* /*
* Data Structures * Data Structures
*/ */

76
modules/video/src/bgfg_gmg.cpp
View File

@ -67,7 +67,7 @@ BackgroundSubtractorGMG::BackgroundSubtractorGMG()
smoothingRadius = 7; smoothingRadius = 7;
} }
void BackgroundSubtractorGMG::initializeType(InputArray _image,flexitype min, flexitype max) void BackgroundSubtractorGMG::initializeType(InputArray _image, double min, double max)
{ {
minVal = min; minVal = min;
maxVal = max; maxVal = max;
@ -114,7 +114,6 @@ void BackgroundSubtractorGMG::initializeType(InputArray _image,flexitype min, fl
* Detect and accommodate the image depth * Detect and accommodate the image depth
*/ */
Mat image = _image.getMat(); Mat image = _image.getMat();
imageDepth = image.depth(); // 32f, 8u, etc.
numChannels = image.channels(); numChannels = image.channels();
/* /*
@ -127,16 +126,15 @@ void BackgroundSubtractorGMG::initializeType(InputArray _image,flexitype min, fl
/* /*
* Data Structure Initialization * Data Structure Initialization
*/ */
Size imsize = image.size(); imWidth = image.cols;
imWidth = imsize.width; imHeight = image.rows;
imHeight = imsize.height; numPixels = image.total();
numPixels = imWidth*imHeight;
pixels.resize(numPixels); pixels.resize(numPixels);
frameNum = 0; frameNum = 0;
// used to iterate through matrix of type unknown at compile time // used to iterate through matrix of type unknown at compile time
elemSize = image.elemSize(); //elemSize = image.elemSize();
elemSize1 = image.elemSize1(); //elemSize1 = image.elemSize1();
vector<PixelModelGMG>::iterator pixel; vector<PixelModelGMG>::iterator pixel;
vector<PixelModelGMG>::iterator pixel_end = pixels.end(); vector<PixelModelGMG>::iterator pixel_end = pixels.end();
@ -145,8 +143,8 @@ void BackgroundSubtractorGMG::initializeType(InputArray _image,flexitype min, fl
pixel->setMaxFeatures(maxFeatures); pixel->setMaxFeatures(maxFeatures);
} }
fgMaskImage = Mat::zeros(imHeight,imWidth,CV_8UC1); // 8-bit unsigned mask. 255 for FG, 0 for BG fgMaskImage = Mat::zeros(imHeight, imWidth, CV_8UC1); // 8-bit unsigned mask. 255 for FG, 0 for BG
posteriorImage = Mat::zeros(imHeight,imWidth,CV_32FC1); // float for storing probabilities. Can be viewed directly with imshow. posteriorImage = Mat::zeros(imHeight, imWidth, CV_32FC1); // float for storing probabilities. Can be viewed directly with imshow.
isDataInitialized = true; isDataInitialized = true;
} }
@ -171,7 +169,7 @@ void BackgroundSubtractorGMG::operator()(InputArray _image, OutputArray _fgmask,
Mat image = _image.getMat(); Mat image = _image.getMat();
_fgmask.create(Size(imHeight,imWidth),CV_8U); _fgmask.create(imHeight,imWidth,CV_8U);
fgMaskImage = _fgmask.getMat(); // 8-bit unsigned mask. 255 for FG, 0 for BG fgMaskImage = _fgmask.getMat(); // 8-bit unsigned mask. 255 for FG, 0 for BG
/* /*
@ -183,54 +181,32 @@ void BackgroundSubtractorGMG::operator()(InputArray _image, OutputArray _fgmask,
vector<PixelModelGMG>::iterator pixel; vector<PixelModelGMG>::iterator pixel;
vector<PixelModelGMG>::iterator pixel_end = pixels.end(); vector<PixelModelGMG>::iterator pixel_end = pixels.end();
size_t i; size_t i;
//#pragma omp parallel //#pragma omp parallel
for (i = 0, pixel=pixels.begin(); pixel != pixel_end; ++i,++pixel) for (i = 0, pixel=pixels.begin(); pixel != pixel_end; ++i,++pixel)
{ {
HistogramFeatureGMG newFeature; HistogramFeatureGMG newFeature;
newFeature.color.clear(); newFeature.color.clear();
int irow = int(i / imWidth);
int icol = i % imWidth;
for (size_t c = 0; c < numChannels; ++c) for (size_t c = 0; c < numChannels; ++c)
{ {
/* /*
* Perform quantization. in each channel. (color-min)*(levels)/(max-min). * Perform quantization. in each channel. (color-min)*(levels)/(max-min).
* Shifts min to 0 and scales, finally casting to an int. * Shifts min to 0 and scales, finally casting to an int.
*/ */
size_t quantizedColor; double color;
// pixel at data+elemSize*i. Individual channel c at data+elemSize*i+elemSize1*c switch(image.depth())
if (imageDepth == CV_8U)
{ {
uchar *color = (uchar*)(image.data+elemSize*i+elemSize1*c); case CV_8U: color = image.ptr<uchar>(irow)[icol * numChannels + c]; break;
quantizedColor = (size_t)((double)(*color-minVal.uc)*quantizationLevels/(maxVal.uc-minVal.uc)); case CV_8S: color = image.ptr<schar>(irow)[icol * numChannels + c]; break;
} case CV_16U: color = image.ptr<ushort>(irow)[icol * numChannels + c]; break;
else if (imageDepth == CV_8S) case CV_16S: color = image.ptr<short>(irow)[icol * numChannels + c]; break;
{ case CV_32S: color = image.ptr<int>(irow)[icol * numChannels + c]; break;
char *color = (char*)(image.data+elemSize*i+elemSize1*c); case CV_32F: color = image.ptr<float>(irow)[icol * numChannels + c]; break;
quantizedColor = (size_t)((double)(*color-minVal.c)*quantizationLevels/(maxVal.c-minVal.c)); case CV_64F: color = image.ptr<double>(irow)[icol * numChannels + c]; break;
} default: color = 0; break;
else if (imageDepth == CV_16U)
{
unsigned int *color = (unsigned int*)(image.data+elemSize*i+elemSize1*c);
quantizedColor = (size_t)((double)(*color-minVal.ui)*quantizationLevels/(maxVal.ui-minVal.ui));
}
else if (imageDepth == CV_16S)
{
int *color = (int*)(image.data+elemSize*i+elemSize1*c);
quantizedColor = (size_t)((double)(*color-minVal.i)*quantizationLevels/(maxVal.i-minVal.i));
}
else if (imageDepth == CV_32F)
{
float *color = (float*)image.data+elemSize*i+elemSize1*c;
quantizedColor = (size_t)((double)(*color-minVal.ui)*quantizationLevels/(maxVal.ui-minVal.ui));
}
else if (imageDepth == CV_32S)
{
long int *color = (long int*)(image.data+elemSize*i+elemSize1*c);
quantizedColor = (size_t)((double)(*color-minVal.li)*quantizationLevels/(maxVal.li-minVal.li));
}
else if (imageDepth == CV_64F)
{
double *color = (double*)image.data+elemSize*i+elemSize1*c;
quantizedColor = (size_t)((double)(*color-minVal.d)*quantizationLevels/(maxVal.d-minVal.d));
} }
size_t quantizedColor = (size_t)((color-minVal)*quantizationLevels/(maxVal-minVal));
newFeature.color.push_back(quantizedColor); newFeature.color.push_back(quantizedColor);
} }
// now that the feature is ready for use, put it in the histogram // now that the feature is ready for use, put it in the histogram
@ -251,7 +227,7 @@ void BackgroundSubtractorGMG::operator()(InputArray _image, OutputArray _fgmask,
*/ */
int row,col; int row,col;
col = i%imWidth; col = i%imWidth;
row = (i-col)/imWidth; row = int(i-col)/imWidth;
posteriorImage.at<float>(row,col) = (1.0f-posterior); posteriorImage.at<float>(row,col) = (1.0f-posterior);
} }
pixel->setLastObservedFeature(newFeature); pixel->setLastObservedFeature(newFeature);
@ -284,10 +260,10 @@ void BackgroundSubtractorGMG::updateBackgroundModel(InputArray _mask)
Mat maskImg = _mask.getMat(); Mat maskImg = _mask.getMat();
//#pragma omp parallel //#pragma omp parallel
for (size_t i = 0; i < imHeight; ++i) for (int i = 0; i < imHeight; ++i)
{ {
//#pragma omp parallel //#pragma omp parallel
for (size_t j = 0; j < imWidth; ++j) for (int j = 0; j < imWidth; ++j)
{ {
if (frameNum <= numInitializationFrames + 1) if (frameNum <= numInitializationFrames + 1)
{ {

313
modules/video/test/test_backgroundsubtractor_gbh.cpp
View File

@ -12,9 +12,9 @@ using namespace cv;
class CV_BackgroundSubtractorTest : public cvtest::BaseTest class CV_BackgroundSubtractorTest : public cvtest::BaseTest
{ {
public: public:
CV_BackgroundSubtractorTest(); CV_BackgroundSubtractorTest();
protected: protected:
void run(int); void run(int);
}; };
CV_BackgroundSubtractorTest::CV_BackgroundSubtractorTest() CV_BackgroundSubtractorTest::CV_BackgroundSubtractorTest()
@ -29,172 +29,167 @@ CV_BackgroundSubtractorTest::CV_BackgroundSubtractorTest()
*/ */
void CV_BackgroundSubtractorTest::run(int) void CV_BackgroundSubtractorTest::run(int)
{ {
int code = cvtest::TS::OK; int code = cvtest::TS::OK;
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
int type = ((unsigned int)rng)%7; //!< pick a random type, 0 - 6, defined in types_c.h int type = ((unsigned int)rng)%7; //!< pick a random type, 0 - 6, defined in types_c.h
int channels = 1 + ((unsigned int)rng)%4; //!< random number of channels from 1 to 4. int channels = 1 + ((unsigned int)rng)%4; //!< random number of channels from 1 to 4.
int channelsAndType = CV_MAKETYPE(type,channels); int channelsAndType = CV_MAKETYPE(type,channels);
int width = 2 + ((unsigned int)rng)%98; //!< Mat will be 2 to 100 in width and height int width = 2 + ((unsigned int)rng)%98; //!< Mat will be 2 to 100 in width and height
int height = 2 + ((unsigned int)rng)%98; int height = 2 + ((unsigned int)rng)%98;
Ptr<BackgroundSubtractorGMG> fgbg = Ptr<BackgroundSubtractorGMG> fgbg =
Algorithm::create<BackgroundSubtractorGMG>("BackgroundSubtractor.GMG"); Algorithm::create<BackgroundSubtractorGMG>("BackgroundSubtractor.GMG");
Mat fgmask; Mat fgmask;
if (fgbg == NULL) if (fgbg == NULL)
CV_Error(CV_StsError,"Failed to create Algorithm\n"); CV_Error(CV_StsError,"Failed to create Algorithm\n");
/** /**
* Set a few parameters * Set a few parameters
*/ */
fgbg->set("smoothingRadius",7); fgbg->set("smoothingRadius",7);
fgbg->set("decisionThreshold",0.7); fgbg->set("decisionThreshold",0.7);
fgbg->set("initializationFrames",120); fgbg->set("initializationFrames",120);
/** /**
* Generate bounds for the values in the matrix for each type * Generate bounds for the values in the matrix for each type
*/ */
uchar maxuc = 0, minuc = 0; uchar maxuc = 0, minuc = 0;
char maxc = 0, minc = 0; char maxc = 0, minc = 0;
uint maxui = 0, minui = 0; unsigned int maxui = 0, minui = 0;
int maxi=0, mini = 0; int maxi=0, mini = 0;
long int maxli = 0, minli = 0; long int maxli = 0, minli = 0;
float maxf = 0, minf = 0; float maxf = 0, minf = 0;
double maxd = 0, mind = 0; double maxd = 0, mind = 0;
/** /**
* Max value for simulated images picked randomly in upper half of type range * Max value for simulated images picked randomly in upper half of type range
* Min value for simulated images picked randomly in lower half of type range * Min value for simulated images picked randomly in lower half of type range
*/ */
if (type == CV_8U) if (type == CV_8U)
{ {
unsigned char half = UCHAR_MAX/2; uchar half = UCHAR_MAX/2;
maxuc = (unsigned char)rng.uniform(half+32,UCHAR_MAX); maxuc = (unsigned char)rng.uniform(half+32, UCHAR_MAX);
minuc = (unsigned char)rng.uniform(0,half-32); minuc = (unsigned char)rng.uniform(0, half-32);
} }
else if (type == CV_8S) else if (type == CV_8S)
{ {
char half = CHAR_MAX/2 + CHAR_MIN/2; maxc = (char)rng.uniform(32, CHAR_MAX);
maxc = (char)rng.uniform(half+32,CHAR_MAX); minc = (char)rng.uniform(CHAR_MIN, -32);
minc = (char)rng.uniform(CHAR_MIN,half-32); }
} else if (type == CV_16U)
else if (type == CV_16U) {
{ ushort half = USHRT_MAX/2;
uint half = UINT_MAX/2; maxui = (unsigned int)rng.uniform(half+32, USHRT_MAX);
maxui = (unsigned int)rng.uniform((int)half+32,UINT_MAX); minui = (unsigned int)rng.uniform(0, half-32);
minui = (unsigned int)rng.uniform(0,(int)half-32); }
} else if (type == CV_16S)
else if (type == CV_16S) {
{ maxi = rng.uniform(32, SHRT_MAX);
int half = INT_MAX/2 + INT_MIN/2; mini = rng.uniform(SHRT_MIN, -32);
maxi = rng.uniform(half+32,INT_MAX); }
mini = rng.uniform(INT_MIN,half-32); else if (type == CV_32S)
} {
else if (type == CV_32S) maxli = rng.uniform(32, INT_MAX);
{ minli = rng.uniform(INT_MIN, -32);
long int half = LONG_MAX/2 + LONG_MIN/2; }
maxli = rng.uniform((int)half+32,(int)LONG_MAX); else if (type == CV_32F)
minli = rng.uniform((int)LONG_MIN,(int)half-32); {
} maxf = rng.uniform(32.0f, FLT_MAX);
else if (type == CV_32F) minf = rng.uniform(-FLT_MAX, -32.0f);
{ }
float half = FLT_MAX/2.0 + FLT_MIN/2.0; else if (type == CV_64F)
maxf = rng.uniform(half+(float)32.0*FLT_EPSILON,FLT_MAX); {
minf = rng.uniform(FLT_MIN,half-(float)32.0*FLT_EPSILON); maxd = rng.uniform(32.0, DBL_MAX);
} mind = rng.uniform(-DBL_MAX, -32.0);
else if (type == CV_64F) }
{
double half = DBL_MAX/2.0 + DBL_MIN/2.0;
maxd = rng.uniform(half+(double)32.0*DBL_EPSILON,DBL_MAX);
mind = rng.uniform(DBL_MIN,half-(double)32.0*DBL_EPSILON);
}
Mat simImage = Mat::zeros(height,width,channelsAndType); Mat simImage = Mat::zeros(height, width, channelsAndType);
const uint numLearningFrames = 120; const unsigned int numLearningFrames = 120;
for (uint i = 0; i < numLearningFrames; ++i) for (unsigned int i = 0; i < numLearningFrames; ++i)
{ {
/** /**
* Genrate simulated "image" for any type. Values always confined to upper half of range. * Genrate simulated "image" for any type. Values always confined to upper half of range.
*/ */
if (type == CV_8U) if (type == CV_8U)
{ {
rng.fill(simImage,RNG::UNIFORM,(unsigned char)(minuc/2+maxuc/2),maxuc); rng.fill(simImage,RNG::UNIFORM,(unsigned char)(minuc/2+maxuc/2),maxuc);
if (i == 0) if (i == 0)
fgbg->initializeType(simImage,minuc,maxuc); fgbg->initializeType(simImage,minuc,maxuc);
} }
else if (type == CV_8S) else if (type == CV_8S)
{ {
rng.fill(simImage,RNG::UNIFORM,(char)(minc/2+maxc/2),maxc); rng.fill(simImage,RNG::UNIFORM,(char)(minc/2+maxc/2),maxc);
if (i==0) if (i==0)
fgbg->initializeType(simImage,minc,maxc); fgbg->initializeType(simImage,minc,maxc);
} }
else if (type == CV_16U) else if (type == CV_16U)
{ {
rng.fill(simImage,RNG::UNIFORM,(unsigned int)(minui/2+maxui/2),maxui); rng.fill(simImage,RNG::UNIFORM,(unsigned int)(minui/2+maxui/2),maxui);
if (i==0) if (i==0)
fgbg->initializeType(simImage,minui,maxui); fgbg->initializeType(simImage,minui,maxui);
} }
else if (type == CV_16S) else if (type == CV_16S)
{ {
rng.fill(simImage,RNG::UNIFORM,(int)(mini/2+maxi/2),maxi); rng.fill(simImage,RNG::UNIFORM,(int)(mini/2+maxi/2),maxi);
if (i==0) if (i==0)
fgbg->initializeType(simImage,mini,maxi); fgbg->initializeType(simImage,mini,maxi);
} }
else if (type == CV_32F) else if (type == CV_32F)
{ {
rng.fill(simImage,RNG::UNIFORM,(float)(minf/2.0+maxf/2.0),maxf); rng.fill(simImage,RNG::UNIFORM,(float)(minf/2.0+maxf/2.0),maxf);
if (i==0) if (i==0)
fgbg->initializeType(simImage,minf,maxf); fgbg->initializeType(simImage,minf,maxf);
} }
else if (type == CV_32S) else if (type == CV_32S)
{ {
rng.fill(simImage,RNG::UNIFORM,(long int)(minli/2+maxli/2),maxli); rng.fill(simImage,RNG::UNIFORM,(long int)(minli/2+maxli/2),maxli);
if (i==0) if (i==0)
fgbg->initializeType(simImage,minli,maxli); fgbg->initializeType(simImage,minli,maxli);
} }
else if (type == CV_64F) else if (type == CV_64F)
{ {
rng.fill(simImage,RNG::UNIFORM,(double)(mind/2.0+maxd/2.0),maxd); rng.fill(simImage,RNG::UNIFORM,(double)(mind/2.0+maxd/2.0),maxd);
if (i==0) if (i==0)
fgbg->initializeType(simImage,mind,maxd); fgbg->initializeType(simImage,mind,maxd);
} }
/** /**
* Feed simulated images into background subtractor * Feed simulated images into background subtractor
*/ */
(*fgbg)(simImage,fgmask); (*fgbg)(simImage,fgmask);
Mat fullbg = Mat::zeros(Size(simImage.cols,simImage.rows),CV_8U); Mat fullbg = Mat::zeros(simImage.rows, simImage.cols, CV_8U);
fgbg->updateBackgroundModel(fullbg); fgbg->updateBackgroundModel(fullbg);
//! fgmask should be entirely background during training //! fgmask should be entirely background during training
code = cvtest::cmpEps2( ts, fgmask, fullbg, 0, false, "The training foreground mask" ); code = cvtest::cmpEps2( ts, fgmask, fullbg, 0, false, "The training foreground mask" );
if (code < 0) if (code < 0)
ts->set_failed_test_info( code ); ts->set_failed_test_info( code );
} }
//! generate last image, distinct from training images //! generate last image, distinct from training images
if (type == CV_8U) if (type == CV_8U)
rng.fill(simImage,RNG::UNIFORM,minuc,minuc); rng.fill(simImage,RNG::UNIFORM,minuc,minuc);
else if (type == CV_8S) else if (type == CV_8S)
rng.fill(simImage,RNG::UNIFORM,minc,minc); rng.fill(simImage,RNG::UNIFORM,minc,minc);
else if (type == CV_16U) else if (type == CV_16U)
rng.fill(simImage,RNG::UNIFORM,minui,minui); rng.fill(simImage,RNG::UNIFORM,minui,minui);
else if (type == CV_16S) else if (type == CV_16S)
rng.fill(simImage,RNG::UNIFORM,mini,mini); rng.fill(simImage,RNG::UNIFORM,mini,mini);
else if (type == CV_32F) else if (type == CV_32F)
rng.fill(simImage,RNG::UNIFORM,minf,minf); rng.fill(simImage,RNG::UNIFORM,minf,minf);
else if (type == CV_32S) else if (type == CV_32S)
rng.fill(simImage,RNG::UNIFORM,minli,minli); rng.fill(simImage,RNG::UNIFORM,minli,minli);
else if (type == CV_64F) else if (type == CV_64F)
rng.fill(simImage,RNG::UNIFORM,mind,mind); rng.fill(simImage,RNG::UNIFORM,mind,mind);
(*fgbg)(simImage,fgmask); (*fgbg)(simImage,fgmask);
//! now fgmask should be entirely foreground //! now fgmask should be entirely foreground
Mat fullfg = 255*Mat::ones(Size(simImage.cols,simImage.rows),CV_8U); Mat fullfg = 255*Mat::ones(simImage.rows, simImage.cols, CV_8U);
code = cvtest::cmpEps2( ts, fgmask, fullfg, 255, false, "The final foreground mask" ); code = cvtest::cmpEps2( ts, fgmask, fullfg, 255, false, "The final foreground mask" );
if (code < 0) if (code < 0)
{ {
ts->set_failed_test_info( code ); ts->set_failed_test_info( code );
} }
} }