Select Git revision
Code owners
Assign users and groups as approvers for specific file changes. Learn more.
Demo2.cpp 24.90 KiB
/*
./bgs_demo -i test45/ -a 100 -o test45/results/
based on original demo.cpp
*/
//cpp c
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <stdio.h> /* printf, scanf, puts, NULL */
#include <stdlib.h> /* srand, rand */
#include <time.h> /* time */
#include <ctime>
#define PROCESS_CENTER_VERSION_MAJOR 0
#define PROCESS_CENTER_VERSION_MINOR 2
//opencv
#include <opencv2/opencv.hpp>
//bgslibrary
#include "package_bgs/bgslibrary.h"
//my class
#include "package_bgs/Tapter.h"
#include "package_bgs/ttoolbox.h"
using namespace cv;
using namespace std;
char* getCmdOption(char ** begin, char ** end, const std::string & option)
{
char ** itr = std::find(begin, end, option);
if (itr != end && ++itr != end)
{
return *itr;
}
return 0;
}
bool cmdOptionExists(char** begin, char** end, const std::string& option)
{
return std::find(begin, end, option) != end;
}
int main(int argc, char * argv[])
{
std::cout << "using produce bk " <<PROCESS_CENTER_VERSION_MAJOR <<"."<< PROCESS_CENTER_VERSION_MINOR << endl;
std::cout << "Using OpenCV " << CV_MAJOR_VERSION << "." << CV_MINOR_VERSION << "." << CV_SUBMINOR_VERSION << std::endl;
//!** parse programm input****************/
if(cmdOptionExists(argv, argv+argc, "-h"))
{
cout <<" error: please use command as\n./bgs_demo -i pathToInputDir -a amountOfJpgFiles -c exactCenterConfFile.xml -o outPutPath"<<endl;
return EXIT_FAILURE;
}
if(!cmdOptionExists(argv, argv+argc, "-i")||!cmdOptionExists(argv, argv+argc, "-a")||!cmdOptionExists(argv, argv+argc, "-o") )
{
cout <<" error: please use command as\n./bgs_demo -i pathToInputDir -a amountOfJpgFiles -c exactCenterConfFile.xml -o outPutPath"<<endl;
return EXIT_FAILURE;
}
char *testInputDir = getCmdOption(argv, argv + argc, "-i");
string inputDir(".");
if (testInputDir)
{
//test dir exists
inputDir = string(testInputDir);
}
int amountFiles = -1;
char *testFileAmount = getCmdOption(argv, argv + argc, "-a"); if (testFileAmount)
{
string s(testFileAmount);
stringstream foo(s);
foo >> amountFiles;
}
char *centerFile = getCmdOption(argv, argv + argc, "-c");
string centerFileString(".");
if (centerFile)
{
//test dir exists
centerFileString = string(centerFile);
}
char *testOutputDir = getCmdOption(argv, argv + argc, "-o");
string outputDir(".");
if (testOutputDir)
{
//test dir exists
outputDir = string(testOutputDir);
}
cout <<"args: -i "<<inputDir<<" -a "<<amountFiles << " -c" << centerFileString<<" -o " << outputDir;
//!**** end parse input***********/
//./program -i pathToInputDir -a amountOfJpgFiles -o outPutPath
//pathToInputDir
//----should have
// centerFile.xml
// -data/
// #which include all jpg and tt files
// first file mus be: 0000000000.jpg
// -bk.jpg
// #is the neutral bk file for training the bgs method
//
// VideoCapture capture;
// if (argc > 1)
// {
// std::cout << "Openning: " << argv[1] << std::endl;
// capture.open(argv[1]);
// }
// else
// capture.open(0);
// if (!capture.isOpened())
// {
// std::cerr << "Cannot initialize video!" << std::endl;
// return -1;
// }
/* Background Subtraction Methods */
//IBGS *bgs;
//bgs = new FrameDifference;
//bgs = new StaticFrameDifference;
//bgs = new WeightedMovingMean;
//bgs = new WeightedMovingVariance;
//bgs = new MixtureOfGaussianV1; // only on OpenCV 2.x
//bgs = new MixtureOfGaussianV2;
//bgs = new AdaptiveBackgroundLearning;
//bgs = new AdaptiveSelectiveBackgroundLearning;
//bgs = new GMG; // only on OpenCV 2.x
//bgs = new KNN; // only on OpenCV 3.x
//bgs = new DPAdaptiveMedian; //bgs = new DPGrimsonGMM;
//bgs = new DPZivkovicAGMM;
//bgs = new DPMean;
//bgs = new DPWrenGA;
//bgs = new DPPratiMediod;
//bgs = new DPEigenbackground;
//bgs = new DPTexture;
//bgs = new T2FGMM_UM;
//bgs = new T2FGMM_UV;
//bgs = new T2FMRF_UM;
//bgs = new T2FMRF_UV;
//bgs = new FuzzySugenoIntegral;
//bgs = new FuzzyChoquetIntegral;
//bgs = new MultiLayer;
//bgs = new PixelBasedAdaptiveSegmenter;
//bgs = new LBSimpleGaussian;
//bgs = new LBFuzzyGaussian;
//bgs = new LBMixtureOfGaussians;
//bgs = new LBAdaptiveSOM;
//bgs = new LBFuzzyAdaptiveSOM;
//bgs = new LBP_MRF;
//bgs = new VuMeter;
//bgs = new KDE;
//bgs = new IndependentMultimodal;
//bgs = new MultiCue;
//bgs = new SigmaDelta;
//bgs = new SuBSENSE;
//bgs = new LOBSTER;
//bgs = new PAWCS;
//bgs = new TwoPoints;
//bgs = new ViBe;
//bgs = new Tapter;
Tapter *bgs = new Tapter;
// bgs->setPathOut(outputDir);
// bgs->setInitialFrameCounter(0);
// bgs->setFlagWrite(0);
// bgs->setFlagWriteDBGpic(0);
//see paper https://dl.acm.org/citation.cfm?id=2321600
//https://ieeexplore.ieee.org/document/4527178/
//was in benchmark on top https://www.researchgate.net/publication/259340906_A_comprehensive_review_of_background_subtraction_algorithms_evaluated_with_synthetic_and_real_videos
//my own adapter to use the model
int i= 0;
cv::Mat img_input;
//init the random number generator
srand (time(NULL));
clock_t beginAll = clock();
//! we read the center config file for cut out the ROI
//TODO merge this config with the Tapter.xml ??
//circle param
int circleCenterX = 880;
int circleCenterY = 750;
int circleRadius = 700;
cv::String configFileNameCenter(centerFileString);
//read the config
cout << "parameter of centerConfigFile.xml"<<endl;
FileStorage fsCen;
fsCen.open(configFileNameCenter, FileStorage::READ);
if (!fsCen.isOpened())
{
cout << "error during open " <<centerFileString << " will abort\n ";
return EXIT_FAILURE;
}
circleCenterX = (int) fsCen["circleCenterX"];
cout <<"circleCenterX: "<< circleCenterX<<endl;
circleCenterY = (int) fsCen["circleCenterY"];
cout <<"circleCenterY: "<< circleCenterY<<endl;
circleRadius = (int) fsCen["circleRadius"];
cout <<"circleRadius: "<< circleRadius<<endl;
fsCen.release();
// //first the static pic**********
// //std::string fileName = getFileName(begin);
// std::string staticFile = inputDir+"/bk.jpg";
// cout <<"a) load first static background pic :"<< staticFile<<endl;
// img_input = imread(staticFile.c_str(), CV_LOAD_IMAGE_COLOR);
// if(img_input.data )
// {
// //we cut out a smaller ROI
// img_input = TToolBox::cropImageCircle(img_input,circleCenterX,circleCenterY,circleRadius);
// cv::Mat img_mask;
// cv::Mat img_bkgmodel;
// bgs->process(img_input, img_mask, img_bkgmodel);
// }
// else
// {
// cout<<"error loading file: "<< staticFile<<", will abort"<<endl;
// return EXIT_FAILURE;
// }
std::string fileName;
//! we train with first x on random draws
//int amountTrainingSteps = 2;
// //we open the config file and readin
// cv::String configFileName("./config/Tapter.xml");
// {//read the config
// FileStorage fs;
// fs.open(configFileName, FileStorage::READ);
// if (!fs.isOpened())
// {
// cout << "error during open " << configFileName << " will abort " <<endl;
// return EXIT_FAILURE;
// }
// //param
// amountTrainingSteps = (int) fs["trainingSteps"];
// //cout <<"amountTrainingSteps: "<< amountTrainingSteps<< endl;
// fs.release();
// }
cout <<"a) we choose two random file "<< fileName<<endl;
//int j=255;
vector<Mat> picsMask;
vector<Mat> picsOrigin;
int maxTrain = 10;
vector<string> myRandomTrainList; //we save all draws in a list which will save to the results
for(i=0;i<maxTrain;i++)
{
//random index
int index = rand() % amountFiles; //TODO: double check no double draw ??
fileName = inputDir + TToolBox::getFileName(index);
myRandomTrainList.push_back(fileName);
cout <<"\t"<<i <<"\t of \t"<<maxTrain<<" rnd file :"<< fileName<<endl;
img_input = imread(fileName.c_str(), CV_LOAD_IMAGE_COLOR);
if(img_input.data )
{
//we cut out a smaller ROI
img_input = TToolBox::cropImageCircle(img_input,circleCenterX,circleCenterY,circleRadius);
//cv::imshow("input", img_input);
cv::Mat img_mask;
cv::Mat img_bkgmodel;
// //adapter learning rate
// if(j>62)
// bgs->setLearningRate(j);
bgs->process(img_input, img_mask, img_bkgmodel); // by default, it shows automatically the foreground mask image
if(i>=(maxTrain-2))
{
picsMask.push_back(img_mask.clone());
picsOrigin.push_back(img_input.clone());
}
// //we save the bk gmodel
// std::string bkTestFileName = inputDir + "bk_"+TToolBox::mNzero(i)+".jpg";
// imwrite(bkTestFileName.c_str(),img_bkgmodel);
}
else
{
cout<<"error loading file: "<< fileName<<", will abort"<<endl;
return EXIT_FAILURE;
}
}
cout <<"b) we calc the two polygones of the points"<< fileName<<endl;
if(picsMask.empty())
{
cout<<"error no pics loaded"<<endl;
return EXIT_FAILURE;
}
else
cout<<"pics.size(): "<<picsMask.size()<<endl;
int frameCounter = 0;
//vector<vector<vector<Point>>> polyGones;
vector<RotatedRect> rectanglesPicA;//we will save the rectangles for each polygone which was selected
vector<RotatedRect> rectanglesPicB;
for(frameCounter=0;frameCounter<2;frameCounter++)
{
Mat img_mask = picsMask[frameCounter];
//! step 3) we make we apply a edge detection
//TODO make this in a function, how many times is this listed ??
//TODO read from tapter config
//TODO all parameter from applyCannyEdgeAndCalcCountours also !!
double threshholdMin = 150;
double threshholdMax = 200;
int apertureSize = 3;
std::vector<vector<Point> > contours = TToolBox::applyCannyEdgeAndCalcCountours(img_mask,threshholdMin,threshholdMax,apertureSize);
// //TODO: we need to order the points to get a nice polygon, otherwise not usefull
// //we also try to find the aproximate polygon*****************
//// vector<Point> aproxiCurve;
//// // //see https://docs.opencv.org/3.4/d3/d63/classcv_1_1Mat.html#a167a8e0a3a3d86e84b70e33483af4466
//// // if(aproxiCurve::checkVector(10,CV_32F)==-1) //// // cout<<"error wrong format of vector"<<endl;
//// //calc 0.1 percent of arc length of convex hull
//// double epsilon = 0.1 * cv::arcLength(hullComplete,true);
//// //see https://docs.opencv.org/2.4.13.2/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#approxpolydp
//// cv::approxPolyDP(allContourPoints,aproxiCurve,epsilon,false);
////#ifdef MC_SHOW_STEP_ANALYSE
//// if(aproxiCurve.size()>=2)//we only draw if we have at least a line
//// {
//// Mat imgPolyApr = Mat::zeros( img_input.size(), CV_8UC3 );
//// imgPolyApr = Scalar(255,255,255); //fille the picture
//// Scalar colorC( 0,0,255,255 );//red
//// //for(imgPolyApr)
//// polylines(imgPolyApr, aproxiCurve, true, colorC, 1, 8);
//// cv::String outpath3= "/homes/tb55xemi/work/bugTrainingSet/testRec/rec04379437pp/result/";
//// std::ostringstream convert3;
//// convert3 << outpath3 << frameCounter <<"_appr_poly.jpg";
//// cv::imwrite(convert3.str().c_str(), imgPolyApr);
//// }
//// else
//// cout<<"approximate poly has not enough points will skip file: "<<frameCounter<<endl;
////#endif
//! step 4) we make a selection out of all counters with area sizes******************************
vector<vector<Point> > contourSelection;
//we exlcude very small one and very big ones
//we calc all min rotated rectangles for all contour from candy egde detect
vector<RotatedRect> minRect( contours.size() );
//calc boxes around the contours
for( size_t i = 0; i < contours.size(); i++ )
minRect[i] = minAreaRect( Mat(contours[i]) ); //may use boundingRect ?? to use fix non rotated rectangles ?
vector<Point2f> recCenterPoints;
float areaMinThreshold = 150;
float areaMaxThreshold = 15000; //TODO apply moving filter ??, an more adaptive approach
//iterate all rectangles
for( size_t i = 0; i< minRect.size(); i++ )
{
Point2f rect_points[4];
//get all points of the retange
minRect[i].points( rect_points );
//construct contour based on rectangle points because contour != rectangle with points
vector<Point> contourRect;
for(int j=0;j<4;j++)
contourRect.push_back(rect_points[j]);
//calc the area of the contour
double area0 = contourArea(contourRect);
//over stepp all small areas
if(area0<areaMinThreshold||area0>areaMaxThreshold)
{
cout<<i<<":area0:"<<area0<<" dismissed "<<endl;
//skipe if the area is too small
continue;
}
else
{
cout<<i<<":area0:"<<area0<<" choose "<<endl; //we add the rectangles to the list
if(frameCounter==0)
rectanglesPicA.push_back(minRect[i]);
if(frameCounter==1)
rectanglesPicB.push_back(minRect[i]);
//get the center of this rectangle
Point2f center = minRect[i].center;
recCenterPoints.push_back(center);
//we also add the this contour to a selection
contourSelection.push_back(contours[i]);
}
}//end iterate all min rectangle
// //! step 5) we calc the moments from the contour selection
// vector<Moments> mu(contourSelection.size() );
// for( size_t i = 0; i < contourSelection.size(); i++ )
// {
// mu[i] = moments( contourSelection[i], false );
// }
// // Get the mass centers:
// vector<Point2f> massCenters( contourSelection.size() );
// for( size_t i = 0; i < contourSelection.size(); i++ )
// {
// massCenters[i] = Point2f( mu[i].m10/mu[i].m00 , mu[i].m01/mu[i].m00 );
// }
// //! step 6) calc convex hull of all points of the contour selection *********
// //TODO produce center of convex hull of all polygones
// //TODO double check if ne contour sharing a center point ? nearby ??
// //we merge all points
// vector<Point> allContourPoints;
// for (size_t cC = 0; cC < contourSelection.size(); ++cC)
// for(size_t cP =0; cP < contourSelection[cC].size(); cP++)
// {
// Point currentContourPixel = contourSelection[cC][cP];
// allContourPoints.push_back(currentContourPixel);
// }
// // calc the hull ******************
// vector<Point> conHull(allContourPoints.size());
// convexHull( Mat(allContourPoints), conHull, false );
// // Point roiCenter;
// // float roiRadius;
// //calc the min circle around
// //minEnclosingCircle(conHull,roiCenter,roiRadius);
// //we calc the mass center of the convex hull
// ///we calc the mass center of the convex hull
// Moments muConvexHull;
// Point2f muConvexHullMassCenter(0.0,0.0);
// if(!conHull.empty())
// {
// muConvexHull = moments(conHull, true );
// muConvexHullMassCenter= Point2f( muConvexHull.m10/muConvexHull.m00 , muConvexHull.m01/muConvexHull.m00 );
// }
//#ifdef MC_SHOW_STEP_ANALYSE
// if(!conHull.empty())//if we any elements, we process further
// {
// Mat imgConvexHull = Mat::zeros( img_input.size(), CV_8UC3 );
// imgConvexHull = Scalar(255,255,255); //fille the picture
// Scalar colorB( 0,0,255,255 );//red // polylines(imgConvexHull, hullComplete, true, colorB, 1, 8);
// //draw circle around
// //circle( imgConvexHull, roiCenter, (int) roiRadius, colorB, 2, 8, 0 );
// //we draw it
// cv::String outpath2= outputDir;
// std::ostringstream convert2;
// convert2 << outpath2 <<TToolBox::mNzero(frameCounter) <<"_convex_hull.jpg";
// cv::imwrite(convert2.str().c_str(), imgConvexHull);
// }
// else
// cout<<"convex hull has no points will skip file: "<<i<<endl;
//#endif
// //! step 8: we write down all our results in yml file
// std::string nameOutPutFileData = outputDir + TToolBox::mNzero(frameCounter) + ".yml";
// FileStorage fs(nameOutPutFileData.c_str(), FileStorage::WRITE);
// fs << "masscenters" << massCenters;
// fs << "polygonselection"<< contourSelection;
// fs << "convexhull"<<conHull;
// fs << "masscenterconvexhull"<<muConvexHullMassCenter;
// fs.release();
// //! we write from time to time a dbg picture
// if(frameCounter%everyPic==0)
// {
// Scalar colorRed( 0,0,255,255 );//red
// RNG rng(4344234);
// Mat imgDebugPaint2 = Mat::zeros( img_input.size(), CV_8UC3 );
// imgDebugPaint2 = Scalar(255,255,255); //fill the picture white
// //we write all polyies of the selection and the mass centers with a random color
// for( size_t i = 0; i< contourSelection.size(); i++ )
// {
// //random color
// Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
// //contour
// drawContours( imgDebugPaint2, contourSelection, i, color, 1, LINE_AA);
// //draw the center
// circle( imgDebugPaint2, massCenters[i], 4, color, -1, 8, 0 );
// }
// //we write the convex hull
// if(!conHull.empty())
// {
// //the poly
// polylines(imgDebugPaint2, conHull, true, colorRed, 1, 8);
// //the center
// circle( imgDebugPaint2,muConvexHullMassCenter, 4, colorRed, -1, 8, 0 );
// }
// //we make a copy
// Mat imgOverlay2 = img_input.clone();
// //we add a overlay of our paitings
// addWeighted( imgDebugPaint2, 0.7, imgOverlay2, 0.3, 0.0, imgOverlay2);
// //we write the file down
// std::string nameOutPutFileDBGpic = outputDir + TToolBox::mNzero(frameCounter) + ".jpg";
// imwrite(nameOutPutFileDBGpic.c_str(),imgOverlay2);
// }
}//end for iterate frame
if(rectanglesPicA.empty()||rectanglesPicB.empty())
cout<<"error no retangles found in pics "<<endl;
Mat picA = picsOrigin[0].clone();
Mat picB = picsOrigin[1].clone();
//now we iterate all rectangles in picA and will produce pictures
for(size_t i=0;i<rectanglesPicA.size();i++)
{
std::string filenName = outputDir + "bk_candidate_a_" + TToolBox::mNzero(i) + ".jpg";
cout << "process picA i"<<i<<" name" <<filenName << endl;
//get the points
RotatedRect rectA= rectanglesPicA[i];
Point2f rectApoints[4];
//get all points of the retange
rectA.points( rectApoints );
//@see https://docs.opencv.org/3.4.0/db/dd6/classcv_1_1RotatedRect.html#a69d648b086f26dbce0029facae9bfb2d
//The points array for storing rectangle vertices.
//The order is bottomLeft, topLeft, topRight, bottomRight.
Point2f corner = rectApoints[1];
//we should add some offset
int offset = 50; //TODO double check offset
Point2f cornerOffset= Point2f((float)( corner.x-offset), (float) (corner.y-offset));
Rect rect = rectA.boundingRect();
//TODO check if out of our area
Rect rectOffset = Rect((float) (cornerOffset.x),(float) (cornerOffset.y),(float)(rect.width + offset) ,(float) (rect.height+offset )) ;
Mat imageRoi = picB(rectOffset);
// std::string filenNameROI = outputDir + "bk_test_a_roi_" + TToolBox::mNzero(i) + ".jpg";
// imwrite(filenNameROI.c_str(),imageRoi);
//imageRoi = Scalar( 255, 0, 0); //fill blue)
// std::cout << "rect size: " << rect.size() << std::endl;
// std::cout << "tempResult cols,rows: " << picB.cols << ", " << picB.rows << endl;
cv::Rect rectROI(cornerOffset.x,cornerOffset.y, imageRoi.cols, imageRoi.rows);
imageRoi.copyTo(picA(rectROI));
cout << "."<<endl;
imwrite(filenName.c_str(),picA);
}
//now we iterate all rectangles and will produce pictures
for(size_t i=0;i<rectanglesPicB.size();i++)
{
std::string filenName = outputDir + "bk_candidate_b_" + TToolBox::mNzero(i) + ".jpg";
cout << "process picB i"<<i<<" name" <<filenName << endl;
//get the points
RotatedRect rectB= rectanglesPicB[i];
Point2f rectBpoints[4];
//get all points of the retange
rectB.points( rectBpoints );
//@see https://docs.opencv.org/3.4.0/db/dd6/classcv_1_1RotatedRect.html#a69d648b086f26dbce0029facae9bfb2d
//The points array for storing rectangle vertices.
//The order is bottomLeft, topLeft, topRight, bottomRight.
Point2f corner = rectBpoints[1];
//we should add some offset
int offset = 50; //TODO double check offset
Point2f cornerOffset= Point2f((float)( corner.x-offset), (float) (corner.y-offset));
Rect rect = rectB.boundingRect();
//TODO check if out of our area
Rect rectOffset = Rect((float) (cornerOffset.x),(float)(cornerOffset.y),(float)(rect.width+offset) ,(float) (rect.height+offset)) ;
Mat imageRoi = picA(rectOffset);
// std::string filenNameROI = outputDir + "bk_test_a_roi_" + TToolBox::mNzero(i) + ".jpg";
// imwrite(filenNameROI.c_str(),imageRoi);
//imageRoi = Scalar( 255, 0, 0); //fill blue)
// std::cout << "rect size: " << rect.size() << std::endl;
// std::cout << "tempResult cols,rows: " << picB.cols << ", " << picB.rows << endl;
cv::Rect rectROI(cornerOffset.x,cornerOffset.y, imageRoi.cols, imageRoi.rows);
imageRoi.copyTo(picB(rectROI));
cout << "."<<endl;
imwrite(filenName.c_str(),picB);
}
// //we calc the time which we used for a picture
// clock_t end = clock();
// double elapsedSecs = double(end - begin) / CLOCKS_PER_SEC;
// //we calc the time which was used for all picture
// clock_t endAll = clock();
// double elapsedSecTotal = double(endAll - beginAll) / CLOCKS_PER_SEC;
// cout <<"process single pic:\t"<<elapsedSecs<<" s - \t\t"<<(int)(elapsedSecTotal/60)<<" min -\t"<<(int)(elapsedSecTotal/60/60)<<" h"<<endl;
delete bgs;
// capture.release();
cvDestroyAllWindows();
return 0;
}