void detectAndDrawObjects( Mat& image, LatentSvmDetector& detector, const vector<Scalar>& colors, float overlapThreshold, int numThreads )
{
vector<LatentSvmDetector::ObjectDetection> detections;
TickMeter tm;
tm.start();
detector.detect( image, detections, overlapThreshold, numThreads);
tm.stop();
cout << "Detection time = " << tm.getTimeSec() << " sec" << endl;
const vector<string> classNames = detector.getClassNames();
CV_Assert( colors.size() == classNames.size() );
for( size_t i = 0; i < detections.size(); i++ )
{
const LatentSvmDetector::ObjectDetection& od = detections[i];
rectangle( image, od.rect, colors[od.classID], 3 );
}
// put text over the all rectangles
for( size_t i = 0; i < detections.size(); i++ )
{
const LatentSvmDetector::ObjectDetection& od = detections[i];
putText( image, classNames[od.classID], Point(od.rect.x+4,od.rect.y+13), FONT_HERSHEY_SIMPLEX, 0.55, colors[od.classID], 2 );
}
}
bool ObjectRecognition::readDatabase(const string& dir, vector<Mat>& databaseDescriptors, vector<string>& files)
{
TickMeter tm;
tm.start();
getdir(dir,files);
string outString = "Start Reading Directory.png";
cout << outString << endl;
string extention = ".png";
vector<string>::iterator it = files.begin();
for (unsigned int i = 0;i < files.size();i++)
{
if ( files[i].size() > 4 && files[i].compare( files[i].size() - 4, 4 , extention) == 0)
{
Mat img = imread( dir + files[i] , CV_LOAD_IMAGE_GRAYSCALE );
//if( img.empty() ) cout << "Database descriptor " << files[i] << " can not be read or has no information." << endl;
//cout << files[i] << "\tRows" << img.rows << "\t Cols" << img.cols << "\t Type/Depth: " << img.depth() << endl;
img.assignTo(img, 5);
databaseDescriptors.push_back( img );
}
it++;
}
tm.stop();
cout << "End reading directory in " << tm.getTimeMilli() << " ms, of size " << DB.size() << endl;
return true;
}
int main(int argc, char** argv) {
using namespace std;
using namespace cv;
VideoCapture cap(0);
if (!cap.isOpened())
exit(1);
if (argc > 2) {
cap.set(CV_CAP_PROP_FRAME_WIDTH, atoi(argv[1]));
cap.set(CV_CAP_PROP_FRAME_HEIGHT, atoi(argv[2]));
}
CascadeClassifier cascade;
if (!cascade.load("haarcascade_frontalface_default.xml"))
exit(2);
const char* name = basename(argv[0]);
namedWindow(name);
for (int frame = 1;; frame++) {
static double mean = 0;
TickMeter tm;
Mat img, gray;
tm.start();
cap >> img;
cvtColor(img, gray, CV_BGR2GRAY);
equalizeHist(gray, gray);
vector<Rect> objects;
cascade.detectMultiScale(gray, objects, 1.2, 9,
CV_HAAR_DO_CANNY_PRUNING);
typedef vector<Rect>::const_iterator RCI;
for (RCI i = objects.begin(); i != objects.end(); ++i) {
Point center(cvRound(i->x+i->width/2),cvRound(i->y+i->height/2));
int radius = cvRound(i->width / 2);
circle(img, center, radius, Scalar(128,255,128), 2, 8, 0);
}
imshow(name, img);
tm.stop();
mean += tm.getTimeMilli();
if (frame % 25 == 0) {
printf("avg detect time: %.2f ms\n", mean / 25);
mean = 0;
}
switch (waitKey(10)) {
case 'q': case 27:
exit(0);
break;
}
}
}
int main(int argc, const char* argv[])
{
if (argc != 2)
return -1;
const std::string fname(argv[1]);
cv::namedWindow("CPU", cv::WINDOW_NORMAL);
cv::namedWindow("GPU", cv::WINDOW_OPENGL);
cv::cuda::setGlDevice();
cv::Mat frame;
cv::VideoCapture reader(fname);
cv::cuda::GpuMat d_frame;
cv::Ptr<cv::cudacodec::VideoReader> d_reader = cv::cudacodec::createVideoReader(fname);
TickMeter tm;
std::vector<double> cpu_times;
std::vector<double> gpu_times;
for (;;)
{
tm.reset();
tm.start();
if (!reader.read(frame))
break;
tm.stop();
cpu_times.push_back(tm.getTimeMilli());
tm.reset();
tm.start();
if (!d_reader->nextFrame(d_frame))
break;
tm.stop();
gpu_times.push_back(tm.getTimeMilli());
cv::imshow("CPU", frame);
cv::imshow("GPU", d_frame);
if (cv::waitKey(3) > 0)
break;
}
if (!cpu_times.empty() && !gpu_times.empty())
{
std::cout << std::endl << "Results:" << std::endl;
std::sort(cpu_times.begin(), cpu_times.end());
std::sort(gpu_times.begin(), gpu_times.end());
double cpu_avg = std::accumulate(cpu_times.begin(), cpu_times.end(), 0.0) / cpu_times.size();
double gpu_avg = std::accumulate(gpu_times.begin(), gpu_times.end(), 0.0) / gpu_times.size();
std::cout << "CPU : Avg : " << cpu_avg << " ms FPS : " << 1000.0 / cpu_avg << std::endl;
std::cout << "GPU : Avg : " << gpu_avg << " ms FPS : " << 1000.0 / gpu_avg << std::endl;
}
return 0;
}
bool ObjectRecognition::loadImageDB()
{
TickMeter tm;
tm.start();
vector<string> files;
getdir(DBdirName,files);
string extention = ".png";
vector<string>::iterator it = files.begin();
vector<Mat> descriptorDatabase;
for (unsigned int i = 0;i < files.size();i++)
{
if ( files[i].size() > 4 && files[i].compare( files[i].size() - 4, 4 , extention) == 0)
{
DBobj DBentry;
DBentry.name = files[i];
DBentry.img = imread( DBdirName + files[i] );
if( DBentry.img.empty() ) cout << "Image: " << files[i] << " can not be read or has no information." << endl;
DBentry.img.assignTo(DBentry.img, CV_8U);
//cout << files[i] << "\tRows" << DBentry.img.rows << "\t Cols" << DBentry.img.cols << "\t Type/Depth: " << DBentry.img.depth() << endl;
detectKeypointsSingle(DBentry.img, DBentry.keypoints );
//cout << files[i] << "\t# Keypoints:" << DBentry.keypoints.size() << endl;
if (DBentry.keypoints.size() > 9)
{
computeDescriptorsSingle(DBentry.img, DBentry.keypoints, DBentry.description);
//cout << files[i] << "\t# of Descriptors: " << DBentry.description.rows << "\t# of Dimensions for descriptor: " << DBentry.description.cols
// << "\tType/depth: " << DBentry.description.type() << " | " << DBentry.description.depth() << endl;
descriptorDatabase.push_back(DBentry.description);
DB.push_back( DBentry );
}
}
it++;
}
// Add Database to matcher program.
matcher->add(descriptorDatabase);
matcher->train();
tm.stop();
cout << "End reading directory in " << tm.getTimeMilli() << " ms, of size " << DB.size() << endl;
return true;
}
static void matchDescriptors( const Mat& queryDescriptors, const vector<Mat>& trainDescriptors,
vector<DMatch>& matches, Ptr<DescriptorMatcher>& descriptorMatcher )
{
cout << "< Set train descriptors collection in the matcher and match query descriptors to them..." << endl;
TickMeter tm;
tm.start();
descriptorMatcher->add( trainDescriptors );
descriptorMatcher->train();
tm.stop();
double buildTime = tm.getTimeMilli();
tm.start();
descriptorMatcher->match( queryDescriptors, matches );
tm.stop();
double matchTime = tm.getTimeMilli();
CV_Assert( queryDescriptors.rows == (int)matches.size() || matches.empty() );
cout << "Number of matches: " << matches.size() << endl;
cout << "Build time: " << buildTime << " ms; Match time: " << matchTime << " ms" << endl;
cout << ">" << endl;
}
int main(int argc, char** argv)
{
if( argc < 2 )
{
printPrompt( argv[0] );
return -1;
}
initModule_nonfree();
// Get Input Data
ifstream file(argv[1]);
if ( !file.is_open() )
return false;
string str;
// Image Name
getline( file, str ); getline( file, str );
string image_name = str;
// Cloud Name
getline( file, str ); getline( file, str );
string cloud_name = str;
// width of images to be created.
getline( file, str ); getline( file, str );
int w = atoi(str.c_str());
// height of images to be created
getline( file, str ); getline( file, str );
int h = atoi(str.c_str());
// resolution of voxel grids
getline( file, str ); getline( file, str );
float r = atof(str.c_str());
// f (distance from pinhole)
getline( file, str ); getline( file, str );
float f = atof(str.c_str());
// thetax (initial rotation about X Axis of map)
getline( file, str ); getline( file, str );
float thetaX = atof(str.c_str());
// thetay (initial rotation about Y Axis of map)
getline( file, str ); getline( file, str );
float thetaY = atof(str.c_str());
// number of points to go to
getline( file, str ); getline( file, str );
float nop = atoi(str.c_str());
// Number of divisions
getline( file, str ); getline( file, str );
float divs = atoi(str.c_str());
// Number of images to return
getline( file, str ); getline( file, str );
int numtoreturn = atoi(str.c_str());
// Should we load or create photos?
getline( file, str ); getline( file, str );
string lorc =str.c_str();
// Directory to look for photos
getline( file, str ); getline( file, str );
string dir =str.c_str();
// Directory to look for kp and descriptors
getline( file, str ); getline( file, str );
string kdir =str.c_str();
// save photos?
getline( file, str ); getline( file, str );
string savePhotos =str.c_str();
file.close();
// Done Getting Input Data
map<vector<float>, Mat> imagemap;
map<vector<float>, Mat> surfmap;
map<vector<float>, Mat> siftmap;
map<vector<float>, Mat> orbmap;
map<vector<float>, Mat> fastmap;
imagemap.clear();
vector<KeyPoint> SurfKeypoints;
vector<KeyPoint> SiftKeypoints;
vector<KeyPoint> OrbKeypoints;
vector<KeyPoint> FastKeypoints;
Mat SurfDescriptors;
Mat SiftDescriptors;
Mat OrbDescriptors;
Mat FastDescriptors;
int minHessian = 300;
SurfFeatureDetector SurfDetector (minHessian);
SiftFeatureDetector SiftDetector (minHessian);
OrbFeatureDetector OrbDetector (minHessian);
FastFeatureDetector FastDetector (minHessian);
SurfDescriptorExtractor SurfExtractor;
SiftDescriptorExtractor SiftExtractor;
OrbDescriptorExtractor OrbExtractor;
if ( !fs::exists( dir ) || lorc == "c" )
{ // Load Point Cloud and render images
PointCloud<PT>::Ptr cloud (new pcl::PointCloud<PT>);
io::loadPCDFile<PT>(cloud_name, *cloud);
Eigen::Affine3f tf = Eigen::Affine3f::Identity();
tf.rotate (Eigen::AngleAxisf (thetaX, Eigen::Vector3f::UnitX()));
pcl::transformPointCloud (*cloud, *cloud, tf);
tf = Eigen::Affine3f::Identity();
tf.rotate (Eigen::AngleAxisf (thetaY, Eigen::Vector3f::UnitY()));
pcl::transformPointCloud (*cloud, *cloud, tf);
// Create images from point cloud
imagemap = render::createImages(cloud, nop, w, h, r, f);
if (savePhotos == "y")
{
for (map<vector<float>, Mat>::iterator i = imagemap.begin(); i != imagemap.end(); ++i)
{
// Create image name and storagename
string imfn = dir + "/";
string kpfn = kdir + "/";
for (int j = 0; j < i->first.size(); j++)
{
imfn += boost::to_string(i->first[j]) + " ";
kpfn += boost::to_string(i->first[j]) + " ";
}
imfn += ".jpg";
imwrite(imfn, i->second);
// Detect keypoints, add to keypoint map. Same with descriptors
SurfDetector.detect(i->second, SurfKeypoints);
SiftDetector.detect(i->second, SiftKeypoints);
OrbDetector.detect(i->second, OrbKeypoints);
FastDetector.detect(i->second, FastKeypoints);
SurfExtractor.compute(i->second, SurfKeypoints, SurfDescriptors);
SiftExtractor.compute(i->second, SiftKeypoints, SiftDescriptors);
OrbExtractor.compute(i->second, OrbKeypoints, OrbDescriptors);
SiftExtractor.compute(i->second, FastKeypoints, FastDescriptors);
// Store KP and Descriptors in yaml file.
kpfn += ".yml";
FileStorage store(kpfn, cv::FileStorage::WRITE);
write(store,"SurfKeypoints",SurfKeypoints);
write(store,"SiftKeypoints",SiftKeypoints);
write(store,"OrbKeypoints", OrbKeypoints);
write(store,"FastKeypoints",FastKeypoints);
write(store,"SurfDescriptors",SurfDescriptors);
write(store,"SiftDescriptors",SiftDescriptors);
write(store,"OrbDescriptors", OrbDescriptors);
write(store,"FastDescriptors",FastDescriptors);
store.release();
surfmap[i->first] = SurfDescriptors;
siftmap[i->first] = SiftDescriptors;
orbmap[i->first] = OrbDescriptors;
fastmap[i->first] = FastDescriptors;
}
}
}
else
{ // load images from the folder dir
// First look into the folder to get a list of filenames
vector<fs::path> ret;
const char * pstr = dir.c_str();
fs::path p(pstr);
get_all(pstr, ret);
for (int i = 0; i < ret.size(); i++)
{
// Load Image via filename
string fn = ret[i].string();
istringstream iss(fn);
vector<string> tokens;
copy(istream_iterator<string>(iss), istream_iterator<string>(), back_inserter<vector<string> >(tokens));
// Construct ID from filename
vector<float> ID;
for (int i = 0; i < 6; i++) // 6 because there are three location floats and three direction floats
ID.push_back(::atof(tokens[i].c_str()));
string imfn = dir + "/" + fn;
// Read image and add to imagemap.
Mat m = imread(imfn);
imagemap[ID] = m;
// Create Filename for loading Keypoints and descriptors
string kpfn = kdir + "/";
for (int j = 0; j < ID.size(); j++)
{
kpfn += boost::to_string(ID[j]) + " ";
}
kpfn = kpfn+ ".yml";
// Create filestorage item to read from and add to map.
FileStorage store(kpfn, cv::FileStorage::READ);
FileNode n1 = store["SurfKeypoints"];
read(n1,SurfKeypoints);
FileNode n2 = store["SiftKeypoints"];
read(n2,SiftKeypoints);
FileNode n3 = store["OrbKeypoints"];
read(n3,OrbKeypoints);
FileNode n4 = store["FastKeypoints"];
read(n4,FastKeypoints);
FileNode n5 = store["SurfDescriptors"];
read(n5,SurfDescriptors);
FileNode n6 = store["SiftDescriptors"];
read(n6,SiftDescriptors);
FileNode n7 = store["OrbDescriptors"];
read(n7,OrbDescriptors);
FileNode n8 = store["FastDescriptors"];
read(n8,FastDescriptors);
store.release();
surfmap[ID] = SurfDescriptors;
siftmap[ID] = SiftDescriptors;
orbmap[ID] = OrbDescriptors;
fastmap[ID] = FastDescriptors;
}
}
TickMeter tm;
tm.reset();
cout << "<\n Analyzing Images ..." << endl;
// We have a bunch of images, now we compute their grayscale and black and white.
map<vector<float>, Mat> gsmap;
map<vector<float>, Mat> bwmap;
for (map<vector<float>, Mat>::iterator i = imagemap.begin(); i != imagemap.end(); ++i)
{
vector<float> ID = i->first;
Mat Image = i-> second;
GaussianBlur( Image, Image, Size(5,5), 0, 0, BORDER_DEFAULT );
gsmap[ID] = averageImage::getPixSumFromImage(Image, divs);
bwmap[ID] = averageImage::aboveBelow(gsmap[ID]);
}
Mat image = imread(image_name);
Mat gsimage = averageImage::getPixSumFromImage(image, divs);
Mat bwimage = averageImage::aboveBelow(gsimage);
// cout << gsimage <<endl;
imwrite("GS.png", gsimage);
namedWindow("GSIMAGE (Line 319)");
imshow("GSIMAGE (Line 319)", gsimage);
waitKey(0);
vector<KeyPoint> imgSurfKeypoints;
vector<KeyPoint> imgSiftKeypoints;
vector<KeyPoint> imgOrbKeypoints;
vector<KeyPoint> imgFastKeypoints;
Mat imgSurfDescriptors;
Mat imgSiftDescriptors;
Mat imgOrbDescriptors;
Mat imgFastDescriptors;
SurfDetector.detect(image, imgSurfKeypoints);
SiftDetector.detect(image, imgSiftKeypoints);
OrbDetector.detect(image, imgOrbKeypoints);
FastDetector.detect(image, imgFastKeypoints);
SurfExtractor.compute(image, imgSurfKeypoints, imgSurfDescriptors);
SiftExtractor.compute(image, imgSiftKeypoints, imgSiftDescriptors);
OrbExtractor.compute(image, imgOrbKeypoints, imgOrbDescriptors);
SiftExtractor.compute(image, imgFastKeypoints, imgFastDescriptors);
tm.start();
cout << ">\n<\n Comparing Images ..." << endl;
// We have their features, now compare them!
map<vector<float>, float> gssim; // Gray Scale Similarity
map<vector<float>, float> bwsim; // Above Below Similarity
map<vector<float>, float> surfsim;
map<vector<float>, float> siftsim;
map<vector<float>, float> orbsim;
map<vector<float>, float> fastsim;
for (map<vector<float>, Mat>::iterator i = gsmap.begin(); i != gsmap.end(); ++i)
{
vector<float> ID = i->first;
gssim[ID] = similarities::getSimilarity(i->second, gsimage);
bwsim[ID] = similarities::getSimilarity(bwmap[ID], bwimage);
surfsim[ID] = similarities::compareDescriptors(surfmap[ID], imgSurfDescriptors);
siftsim[ID] = similarities::compareDescriptors(siftmap[ID], imgSiftDescriptors);
orbsim[ID] = 0;//similarities::compareDescriptors(orbmap[ID], imgOrbDescriptors);
fastsim[ID] = 0;//similarities::compareDescriptors(fastmap[ID], imgFastDescriptors);
}
map<vector<float>, int> top;
bool gotone = false;
typedef map<vector<float>, int>::iterator iter;
// Choose the best ones!
for (map<vector<float>, Mat>::iterator i = imagemap.begin(); i != imagemap.end(); ++i)
{
vector<float> ID = i->first;
int sim = /* gssim[ID] + 0.5*bwsim[ID] + */ 5*surfsim[ID] + 0.3*siftsim[ID] + orbsim[ID] + fastsim[ID];
// cout << surfsim[ID] << "\t";
// cout << siftsim[ID] << "\t";
// cout << orbsim[ID] << "\t";
// cout << fastsim[ID] << endl;
if (!gotone)
{
top[ID] = sim;
gotone = true;
}
iter it = top.begin();
iter end = top.end();
int max_value = it->second;
vector<float> max_ID = it->first;
for( ; it != end; ++it)
{
int current = it->second;
if(current > max_value)
{
max_value = it->second;
max_ID = it->first;
}
}
// cout << "Sim: " << sim << "\tmax_value: " << max_value << endl;
if (top.size() < numtoreturn)
top[ID] = sim;
else
{
if (sim < max_value)
{
top[ID] = sim;
top.erase(max_ID);
}
}
}
tm.stop();
double s = tm.getTimeSec();
cout << ">\n<\n Writing top " << numtoreturn << " images ..." << endl;
int count = 1;
namedWindow("Image");
namedWindow("Match");
namedWindow("ImageBW");
namedWindow("MatchBW");
namedWindow("ImageGS");
namedWindow("MatchGS");
imshow("Image", image);
imshow("ImageBW", bwimage);
imshow("ImageGS", gsimage);
vector<KeyPoint> currentPoints;
for (iter i = top.begin(); i != top.end(); ++i)
{
vector<float> ID = i->first;
cout << " Score: "<< i->second << "\tGrayScale: " << gssim[ID] << "\tBW: " << bwsim[ID] << " \tSURF: " << surfsim[ID] << "\tSIFT: " << siftsim[ID] << endl;
string fn = "Sim_" + boost::to_string(count) + "_" + boost::to_string(i->second) + ".png";
imwrite(fn, imagemap[ID]);
count++;
normalize(bwmap[ID], bwmap[ID], 0, 255, NORM_MINMAX, CV_64F);
normalize(gsmap[ID], gsmap[ID], 0, 255, NORM_MINMAX, CV_64F);
imshow("Match", imagemap[ID]);
imshow("MatchBW", bwmap[ID]);
imshow("MatchGS", gsmap[ID]);
waitKey(0);
}
cout << ">\nComparisons took " << s << " seconds for " << imagemap.size() << " images ("
<< (int) imagemap.size()/s << " images per second)." << endl;
return 0;
}
void bingQdpmRocTest(vector<string> &dirs,
int windowLimit = -1, double timeLimitMs = -1, float ratioThreshold = -1)
{
size_t imageCount = 0;
size_t personCount = 0;
size_t matchCount = 0;
vector<ScoreTp> pScores;
TickMeter tm;
vector<std::string>::const_iterator it = dirs.begin();
char buf[512];
for (; it != dirs.end(); it++) {
string dir = *it;
DataSetVOC voc(dir, true, true);
voc.loadAnnotations();
const size_t testNum = voc.testSet.size();
const char *imgPath =_S(voc.imgPathW);
// Objectness
double base = 2;
double intUionThr = 0.5;
int W = 8;
int NSS = 2;
#ifdef WINDOW_GUESS
Objectness objNess(voc, base, intUionThr, W, NSS);
objNess.loadTrainedModel(TRAIN_MODEL);
#endif
// LSVM DPM
string dpmPersonModel = "../ExtraData/latentsvmXml/person.xml";
vector<string> models;
models.push_back(dpmPersonModel);
QUniLsvmDetector detector(models);
float overlapThreshold = 0.2f;
if (ratioThreshold > 0)
detector.setRatioThreshold(ratioThreshold);
printf("%d: \n", testNum);
for (int i = 0; i < testNum; i++) {
const vector<Vec4i> &boxesGT = voc.gtTestBoxes[i];
const size_t gtNumCrnt = boxesGT.size();
if (gtNumCrnt <= 0)
continue;
imageCount++;
personCount += gtNumCrnt;
Mat image = imread(format(imgPath, _S(voc.testSet[i])));
if (image.ptr() == NULL) {
fprintf(stderr, "No JPG Image !\n");
exit(1);
}
int numPerSz = 130;
ValStructVec<float, Vec4i> boxes;
double preObj = tm.getTimeMilli();
double objTime = 0.;
#ifdef WINDOW_GUESS // window guess
tm.start();
objNess.getObjBndBoxes(image, boxes, numPerSz);
tm.stop();
objTime = tm.getTimeMilli() - preObj;
#endif
double localTimeLimitMs = timeLimitMs;
if (timeLimitMs > 0) {
localTimeLimitMs -= objTime;
if (localTimeLimitMs < 0.)
localTimeLimitMs = 0.;
}
vector<QRect> searchBoxes;
if (windowLimit > 0) {
for (int j = 0; j < (int)boxes.size() && j < windowLimit; j++) {
const Vec4i &bb = boxes[j];
QRect rt(bb[0], bb[1], bb[2], bb[3]);
searchBoxes.push_back(rt);
}
} else {
for (int j = 0; j < (int)boxes.size(); j++) {
const Vec4i &bb = boxes[j];
QRect rt(bb[0], bb[1], bb[2], bb[3]);
searchBoxes.push_back(rt);
}
}
tm.start();
detector.setup(image, overlapThreshold, localTimeLimitMs);
tm.stop();
vector<FeatureMapCoord> ftrMapCoords;
#ifdef WINDOW_GUESS
detector.cvtBox2FtrMapCoord(&searchBoxes, &ftrMapCoords);
#else
detector.genFullFtrMapCoord(&ftrMapCoords);
preObj = tm.getTimeMilli();
tm.start();
#ifdef SHUFFLE_WINDOW
random_shuffle(ftrMapCoords.begin(), ftrMapCoords.end());
#endif
tm.stop();
double randGenTime = tm.getTimeMilli() - preObj;
if (localTimeLimitMs > 0 && localTimeLimitMs - preObj >= 0.)
detector.setTimeLimit(localTimeLimitMs - preObj);
#endif
vector<QUniLsvmDetector::ObjectDetection> detections;
vector<vector<FeatureMapCoord> *> fmcss;
fmcss.push_back(&ftrMapCoords);
tm.start();
detector.detect(detections, fmcss);
tm.stop();
vector<DetectedInfo> di(detections.size());
vector<int> gtIdx(gtNumCrnt, -1);
int detectCount = 0;
for (size_t j = 0; j < detections.size(); j++) {
const QUniLsvmDetector::ObjectDetection& od = detections[j];
if (od.score < RECOMMENDABLE_THRESHOLD)
continue;
detectCount++;
Vec4i bb(od.rect.x + 1, od.rect.y + 1, od.rect.x + od.rect.width, od.rect.y + od.rect.height);
// score matchScore for the ROC curve
double maxMatchScore = 0;
int maxMatchId = -1;
for (int k = 0; k < gtNumCrnt; k++) {
double matchScore = DataSetVOC::interUnio(bb, boxesGT[k]);
if (matchScore > maxMatchScore) {
maxMatchScore = matchScore;
maxMatchId = k;
}
}
uchar match = maxMatchScore > 0.5 ? 1 : 0;
if (match) {
int preDetectedIdx = gtIdx[maxMatchId];
if (preDetectedIdx >= 0) {
if (maxMatchScore > di[preDetectedIdx].matchScore) {
di[preDetectedIdx].matched = false;
gtIdx[maxMatchId] = int(j);
di[j].matchScore = maxMatchScore;
di[j].matched = true;
}
} else {
gtIdx[maxMatchId] = int(j);
di[j].matchScore = maxMatchScore;
di[j].matched = true;
}
}
#ifdef SAVE_IMAGE_RESULT
// save the result image
char buf[256];
sprintf(buf, "%2f", od.score);
Point pt(max((bb[2] + bb[0] - 85) / 2, 0), (bb[1] + bb[3]) / 2);
putText(image, buf, pt, FONT_HERSHEY_SIMPLEX, 0.5, Scalar::all(255), 3, CV_AA);
putText(image, buf, pt, FONT_HERSHEY_SIMPLEX, 0.5, Scalar::all(0), 1, CV_AA);
rectangle(image, od.rect, cv::Scalar(0, 255, 0), 2);
#endif
}
for (size_t j = 0; j < detectCount; j++) { // detections are sorted in descending order
const QUniLsvmDetector::ObjectDetection& od = detections[j];
if (di[j].matched)
matchCount++;
pScores.push_back(ScoreTp(od.score, di[j].matched));
}
#ifdef SAVE_IMAGE_RESULT
imwrite((voc.testSet[i] + "_DpmResult.png").c_str(), image);
#endif
printf("%d ", i + 1);
}
printf("\n");
}
printf("BingQdpmRocTest time = %f sec\n", tm.getTimeSec());
printf("GT %d, Matched %d/%d \n", personCount, matchCount, pScores.size());
// Calculate log-average miss rate
stable_sort(begin(pScores), end(pScores),
[](const ScoreTp &p1, const ScoreTp &p2) { return p1.first > p2.first; });
vector<float> fp(pScores.size());
for (size_t i = 0; i < fp.size(); i++)
fp[i] = !pScores[i].second;
vector<float> tp(pScores.size());
tp[0] = pScores[0].second;
for (size_t i = 1; i < tp.size(); i++)
tp[i] = tp[i - 1] + pScores[i].second;
for (size_t i = 0; i < tp.size(); i++)
tp[i] /= personCount;
for (size_t i = 1; i < fp.size(); i++)
fp[i] += fp[i - 1];
for (size_t i = 0; i < fp.size(); i++)
fp[i] /= imageCount;
sprintf(buf, "%s%03d_%03.fms_6137gt_%04dtp_%04ddt_%.0fs.m",
METHOD_NAME, max(windowLimit, 0), timeLimitMs, matchCount, pScores.size(), tm.getTimeSec());
FILE *matlabFile = fopen(buf, "w");
printVector(matlabFile, tp, "tp");
printVector(matlabFile, fp, "fp");
char *matlabContent = "tp = tp'; fp = fp';\n"
"addpath(genpath('d:/81_dataset/03_Caltech/piotr_toolbox/')); savepath;\n"
"xs1=[-inf; fp];\n"
"ys1=[0; tp];\n"
"ref=10.^(-2:.25:0);\n"
"lims=[3.1e-4 1e1 .5 1];\n"
"m=length(ref);\n"
"for i=1:m\n"
"\tj=find(xs1<=ref(i));\n"
"\tmiss(i)=ys1(j(end));\n"
"end\n"
"miss=exp(mean(log(max(1e-10,1-miss))));\n"
"show=figure();\n"
"plotRoc([fp tp],'logx',1,'logy',1,'xLbl','fppi',...\n"
"\t'lims',lims,'color','g','smooth',1,'fpTarget',ref);\n"
"title(sprintf('log-average miss rate = %.2f%%',miss*100));\n"
"savefig(['MORU' 'Roc'],show,'png');\n";
fwrite(matlabContent, strlen(matlabContent), 1, matlabFile);
fclose(matlabFile);
}
Mat Tracker::process(const Mat frame, Stats& stats)
{
TickMeter tm;
vector<KeyPoint> kp;
Mat desc;
tm.start();
detector->detectAndCompute(frame, noArray(), kp, desc);
stats.keypoints = (int)kp.size();
vector< vector<DMatch> > matches;
vector<KeyPoint> matched1, matched2;
matcher->knnMatch(first_desc, desc, matches, 2);
for(unsigned i = 0; i < matches.size(); i++) {
if(matches[i][0].distance < nn_match_ratio * matches[i][1].distance) {
matched1.push_back(first_kp[matches[i][0].queryIdx]);
matched2.push_back( kp[matches[i][0].trainIdx]);
}
}
stats.matches = (int)matched1.size();
Mat inlier_mask, homography;
vector<KeyPoint> inliers1, inliers2;
vector<DMatch> inlier_matches;
if(matched1.size() >= 4) {
homography = findHomography(Points(matched1), Points(matched2),
RANSAC, ransac_thresh, inlier_mask);
}
tm.stop();
stats.fps = 1. / tm.getTimeSec();
if(matched1.size() < 4 || homography.empty()) {
Mat res;
hconcat(first_frame, frame, res);
stats.inliers = 0;
stats.ratio = 0;
return res;
}
for(unsigned i = 0; i < matched1.size(); i++) {
if(inlier_mask.at<uchar>(i)) {
int new_i = static_cast<int>(inliers1.size());
inliers1.push_back(matched1[i]);
inliers2.push_back(matched2[i]);
inlier_matches.push_back(DMatch(new_i, new_i, 0));
}
}
stats.inliers = (int)inliers1.size();
stats.ratio = stats.inliers * 1.0 / stats.matches;
vector<Point2f> new_bb;
perspectiveTransform(object_bb, new_bb, homography);
Mat frame_with_bb = frame.clone();
if(stats.inliers >= bb_min_inliers) {
drawBoundingBox(frame_with_bb, new_bb);
}
Mat res;
drawMatches(first_frame, inliers1, frame_with_bb, inliers2,
inlier_matches, res,
Scalar(255, 0, 0), Scalar(255, 0, 0));
return res;
}
int main(int argc, const char *argv[])
{
if (getCudaEnabledDeviceCount() == 0)
{
return cerr << "No GPU found or the library is compiled without CUDA support" << endl, -1;
}
cv::cuda::printShortCudaDeviceInfo(cv::cuda::getDevice());
////////////// CAFFE /////////////////////
// Caffe::set_mode(Caffe::GPU);
// Caffe::SetDevice(0);
//
// caffe::Datum* datum = new caffe::Datum();
// CVMatToDatum(cropImg, datum);
//
// // Load net
// // Assume you are in Caffe master directory
// caffe::Net<float> net("/home/k1y0sh1/DeveloperZone/Project/EclipseWorkplace/OpenCV249U1404/Debug/bvlc_googlenet.prototxt", TEST);
//
// // Load pre-trained net (binary proto)
// // Assume you are already trained the cifar10 example.
// net.CopyTrainedLayersFrom("/home/k1y0sh1/DeveloperZone/Project/EclipseWorkplace/OpenCV249U1404/Debug/bvlc_googlenet.caffemodel");
//
// caffe::Blob<float>* input_blob = new caffe::Blob<float>(1, datum->channels(), datum->height(), datum->width());
// //get the blobproto
// caffe::BlobProto blob_proto;
// blob_proto.set_num(1);
// blob_proto.set_channels(datum->channels());
// blob_proto.set_height(datum->height());
// blob_proto.set_width(datum->width());
//
// const string& data = datum->data();
// for (uint32_t i = 0; i < data.length(); ++i) {
// blob_proto.add_data((uint8_t)data[i]);
// }
//
// //set data into blob
// input_blob->FromProto(blob_proto);
//
// std::vector<caffe::Blob<float>*> input_cnn;
// input_cnn.push_back(input_blob);
//
// float loss;
// std::vector<caffe::Blob<float>*> input_blobs = net.input_blobs();
// for (int i = 0; i < input_cnn.size(); ++i) {
// input_blobs[i]->CopyFrom(*input_cnn[i]);
// }
// const std::vector<caffe::Blob<float>*>& result = net.ForwardPrefilled(&loss);
//
// std::cout << "loss: " << loss << "\n";
// // read the 'prob' layer and get the result
//
// shared_ptr<caffe::Blob<float> > prob = net.blob_by_name("prob");
//
// float maxval= 0;
// int maxinx= 0;
// for (int i = 0; i < prob->count(); i++)
// {
// float val = (prob->cpu_data()[i]) * 100;
// if (val> maxval)
// {
// maxval = val;
// maxinx = i;
// }
// std::cout << "[" << i << "]" << val<< "\n";
// }
// std::cout << "Max value = " << maxval << ", Max index = " << maxinx<< "\n";
// Mat cropImg = cv::imread("/home/k1y0sh1/DeveloperZone/Project/EclipseWorkplace/CaffePredictTest/Debug/80.jpg",CV_LOAD_IMAGE_COLOR);
// imshow("crop",cropImg);
// cv::resize(cropImg, cropImg, cv::Size(224, 224));
string model_file = "/home/k1y0sh1/DeveloperZone/Project/EclipseWorkplace/CaffePredictTest/Debug/deploy.prototxt";
string trained_file = "/home/k1y0sh1/DeveloperZone/Project/EclipseWorkplace/CaffePredictTest/Debug/snapshot_iter_14640.caffemodel";
string mean_file = "/home/k1y0sh1/DeveloperZone/Project/EclipseWorkplace/CaffePredictTest/Debug/mean.binaryproto";
string label_file = "/home/k1y0sh1/DeveloperZone/Project/EclipseWorkplace/CaffePredictTest/Debug/labels.txt";
CaffeClassifier CaffeClassifier(model_file, trained_file, mean_file, label_file);
//
// string file = "/home/k1y0sh1/DeveloperZone/Project/EclipseWorkplace/CaffePredictTest/Debug/80.jpg";
//
// std::cout << "---------- Prediction for "
// << file << " ----------" << std::endl;
//
// std::vector<Prediction> predictions = CaffeClassifier.Classify(cropImg,1);
//
// /* Print the top N predictions. */
// for (size_t i = 0; i < predictions.size(); ++i)
// {
// Prediction p = predictions[i];
// std::cout << std::fixed << std::setprecision(4) << p.second << " - \"" << p.first << "\"" << std::endl;
// }
////////////// END CAFFE /////////////////////
////////////// HAAR /////////////////////
string cascadeName = "/home/k1y0sh1/DeveloperZone/HaarTraining/classifiers/cascade.xml";
Ptr<cuda::CascadeClassifier> cascade_gpu = cuda::CascadeClassifier::create(cascadeName);
Mat image;
namedWindow("result", 1);
Mat frame, frame_cpu, gray_cpu, resized_cpu, frameDisp;
vector<Rect> faces;
GpuMat frame_gpu, gray_gpu, resized_gpu, facesBuf_gpu, k_rgb_gpu;
/* parameters */
bool useGPU = true;
double scaleFactor = 0.5;
bool findLargestObject = true;
bool filterRects = true;
bool helpScreen = false;
bool predictObject = false;
////////////// END HAAR /////////////////////
//////////////////// KINECT /////////////////////
std::string program_path(argv[0]);
size_t executable_name_idx = program_path.rfind("OpenCVKinectGPU");
std::string binpath = "/";
if(executable_name_idx != std::string::npos)
{
binpath = program_path.substr(0, executable_name_idx);
}
libfreenect2::Freenect2 freenect2;
libfreenect2::Freenect2Device *dev = 0;
libfreenect2::PacketPipeline *pipeline = 0;
if(freenect2.enumerateDevices() == 0)
{
std::cout << "no device connected!" << std::endl;
return -1;
}
std::string serial = freenect2.getDefaultDeviceSerialNumber();
for(int argI = 1; argI < argc; ++argI)
{
const std::string arg(argv[argI]);
if(arg == "cpu")
{
if(!pipeline)
pipeline = new libfreenect2::CpuPacketPipeline();
}
else if(arg == "gl")
{
#ifdef LIBFREENECT2_WITH_OPENGL_SUPPORT
if(!pipeline)
pipeline = new libfreenect2::OpenGLPacketPipeline();
#else
std::cout << "OpenGL pipeline is not supported!" << std::endl;
#endif
}
else if(arg == "cl")
{
#ifdef LIBFREENECT2_WITH_OPENCL_SUPPORT
if(!pipeline)
pipeline = new libfreenect2::OpenCLPacketPipeline();
#else
std::cout << "OpenCL pipeline is not supported!" << std::endl;
#endif
}
else if(arg.find_first_not_of("0123456789") == std::string::npos) //check if parameter could be a serial number
{
serial = arg;
}
else
{
std::cout << "Unknown argument: " << arg << std::endl;
}
}
if(pipeline)
{
dev = freenect2.openDevice(serial, pipeline);
}
else
{
dev = freenect2.openDevice(serial);
}
if(dev == 0)
{
std::cout << "failure opening device!" << std::endl;
return -1;
}
signal(SIGINT,sigint_handler);
protonect_shutdown = false;
libfreenect2::SyncMultiFrameListener listener(libfreenect2::Frame::Color);
libfreenect2::FrameMap frames;
dev->setColorFrameListener(&listener);
dev->start();
std::cout << "device serial: " << dev->getSerialNumber() << std::endl;
std::cout << "device firmware: " << dev->getFirmwareVersion() << std::endl;
libfreenect2::Registration* registration = new libfreenect2::Registration(dev->getIrCameraParams(), dev->getColorCameraParams());
/////////////////// END KINECT /////////////////
while(!protonect_shutdown)
{
listener.waitForNewFrame(frames);
libfreenect2::Frame *rgb = frames[libfreenect2::Frame::Color];
cv::Mat k_rgb = cv::Mat(rgb->height, rgb->width, CV_8UC4, rgb->data);
image = Mat(k_rgb);
frame_gpu.upload(k_rgb);
cuda::flip(frame_gpu,frame_gpu,1);
cv::flip(image,image,1);
cuda::cvtColor(frame_gpu,k_rgb_gpu,CV_BGRA2BGR);
convertAndResizeGPU(k_rgb_gpu, gray_gpu, resized_gpu, scaleFactor);
convertAndResizeCPU(image,image,scaleFactor);
TickMeter tm;
tm.start();
//cascade_gpu->setMaxNumObjects(2);
//cascade_gpu->setMaxObjectSize(cv::Size(224,224));
//cascade_gpu->setMinObjectSize(cv::Size(0,0));
cascade_gpu->setFindLargestObject(findLargestObject);
cascade_gpu->setScaleFactor(1.2);
cascade_gpu->setMinNeighbors((filterRects || findLargestObject) ? 4 : 0);
cascade_gpu->detectMultiScale(resized_gpu, facesBuf_gpu);
cascade_gpu->convert(facesBuf_gpu, faces);
for (size_t i = 0; i < faces.size(); ++i)
{
//cout<< "object [" << i << "]: " << faces[i].width << " x " << faces[i].height <<endl;
rectangle(image, faces[i], Scalar(255));
cropRect = Rect(image.cols / 2, image.rows / 2,224,224);
Mat cropImg = image(cropRect).clone();
if(predictObject == true)
{
std::vector<Prediction> predictions = CaffeClassifier.Classify(cropImg,1);
/* Print the top N predictions. */
for (size_t i = 0; i < predictions.size(); ++i)
{
Prediction p = predictions[i];
std::cout << std::fixed << std::setprecision(4) << p.second << " - \"" << p.first << "\"" << std::endl;
}
predictObject = false;
}
}
tm.stop();
double detectionTime = tm.getTimeMilli();
double fps = 1000 / detectionTime;
displayState(image, helpScreen, useGPU, findLargestObject, filterRects, fps,scaleFactor);
imshow("result", image);
char key = (char)waitKey(5);
if (key == 27)
{
break;
}
switch (key)
{
case ' ':
useGPU = !useGPU;
break;
case 'm':
case 'M':
findLargestObject = !findLargestObject;
break;
case 'f':
case 'F':
filterRects = !filterRects;
break;
case '1':
scaleFactor *= 1.05;
break;
case 'q':
case 'Q':
scaleFactor /= 1.05;
break;
case 'h':
case 'H':
helpScreen = !helpScreen;
break;
case 'p':
case 'P':
predictObject = !predictObject;
break;
}
protonect_shutdown = protonect_shutdown || (key > 0 && ((key & 0xFF) == 27)); // shutdown on escape
listener.release(frames);
//libfreenect2::this_thread::sleep_for(libfreenect2::chrono::milliseconds(100));
}
resized_gpu.release();
// TODO: restarting ir stream doesn't work!
// TODO: bad things will happen, if frame listeners are freed before dev->stop() :(
dev->stop();
dev->close();
delete registration;
return 0;
}
/*
* This sample helps to evaluate odometry on TUM datasets and benchmark http://vision.in.tum.de/data/datasets/rgbd-dataset.
* At this link you can find instructions for evaluation. The sample runs some opencv odometry and saves a camera trajectory
* to file of format that the benchmark requires. Saved file can be used for online evaluation.
*/
int main(int argc, char** argv)
{
if(argc != 4)
{
cout << "Format: file_with_rgb_depth_pairs trajectory_file odometry_name [Rgbd or ICP or RgbdICP]" << endl;
return -1;
}
vector<string> timestamps;
vector<Mat> Rts;
const string filename = argv[1];
ifstream file( filename.c_str() );
if( !file.is_open() )
return -1;
char dlmrt = '/';
size_t pos = filename.rfind(dlmrt);
string dirname = pos == string::npos ? "" : filename.substr(0, pos) + dlmrt;
const int timestampLength = 17;
const int rgbPathLehgth = 17+8;
const int depthPathLehgth = 17+10;
float fx = 525.0f, // default
fy = 525.0f,
cx = 319.5f,
cy = 239.5f;
if(filename.find("freiburg1") != string::npos)
setCameraMatrixFreiburg1(fx, fy, cx, cy);
if(filename.find("freiburg2") != string::npos)
setCameraMatrixFreiburg2(fx, fy, cx, cy);
Mat cameraMatrix = Mat::eye(3,3,CV_32FC1);
{
cameraMatrix.at<float>(0,0) = fx;
cameraMatrix.at<float>(1,1) = fy;
cameraMatrix.at<float>(0,2) = cx;
cameraMatrix.at<float>(1,2) = cy;
}
Ptr<OdometryFrame> frame_prev = new OdometryFrame(),
frame_curr = new OdometryFrame();
Ptr<Odometry> odometry = Algorithm::create<Odometry>("RGBD." + string(argv[3]) + "Odometry");
if(odometry.empty())
{
cout << "Can not create Odometry algorithm. Check the passed odometry name." << endl;
return -1;
}
odometry->set("cameraMatrix", cameraMatrix);
TickMeter gtm;
int count = 0;
for(int i = 0; !file.eof(); i++)
{
string str;
std::getline(file, str);
if(str.empty()) break;
if(str.at(0) == '#') continue; /* comment */
Mat image, depth;
// Read one pair (rgb and depth)
// example: 1305031453.359684 rgb/1305031453.359684.png 1305031453.374112 depth/1305031453.374112.png
#if BILATERAL_FILTER
TickMeter tm_bilateral_filter;
#endif
{
string rgbFilename = str.substr(timestampLength + 1, rgbPathLehgth );
string timestap = str.substr(0, timestampLength);
string depthFilename = str.substr(2*timestampLength + rgbPathLehgth + 3, depthPathLehgth );
image = imread(dirname + rgbFilename);
depth = imread(dirname + depthFilename, -1);
CV_Assert(!image.empty());
CV_Assert(!depth.empty());
CV_Assert(depth.type() == CV_16UC1);
cout << i << " " << rgbFilename << " " << depthFilename << endl;
// scale depth
Mat depth_flt;
depth.convertTo(depth_flt, CV_32FC1, 1.f/5000.f);
#if not BILATERAL_FILTER
depth_flt.setTo(std::numeric_limits<float>::quiet_NaN(), depth == 0);
depth = depth_flt;
#else
tm_bilateral_filter.start();
depth = Mat(depth_flt.size(), CV_32FC1, Scalar(0));
const double depth_sigma = 0.03;
const double space_sigma = 4.5; // in pixels
Mat invalidDepthMask = depth_flt == 0.f;
depth_flt.setTo(-5*depth_sigma, invalidDepthMask);
bilateralFilter(depth_flt, depth, -1, depth_sigma, space_sigma);
depth.setTo(std::numeric_limits<float>::quiet_NaN(), invalidDepthMask);
tm_bilateral_filter.stop();
cout << "Time filter " << tm_bilateral_filter.getTimeSec() << endl;
#endif
timestamps.push_back( timestap );
}
{
Mat gray;
cvtColor(image, gray, CV_BGR2GRAY);
frame_curr->image = gray;
frame_curr->depth = depth;
Mat Rt;
if(!Rts.empty())
{
TickMeter tm;
tm.start();
gtm.start();
bool res = odometry->compute(frame_curr, frame_prev, Rt);
gtm.stop();
tm.stop();
count++;
cout << "Time " << tm.getTimeSec() << endl;
#if BILATERAL_FILTER
cout << "Time ratio " << tm_bilateral_filter.getTimeSec() / tm.getTimeSec() << endl;
#endif
if(!res)
Rt = Mat::eye(4,4,CV_64FC1);
}
if( Rts.empty() )
Rts.push_back(Mat::eye(4,4,CV_64FC1));
else
{
Mat& prevRt = *Rts.rbegin();
cout << "Rt " << Rt << endl;
Rts.push_back( prevRt * Rt );
}
if(!frame_prev.empty())
frame_prev->release();
std::swap(frame_prev, frame_curr);
}
}
std::cout << "Average time " << gtm.getTimeSec()/count << std::endl;
writeResults(argv[2], timestamps, Rts);
return 0;
}
int main(int argc, const char* argv[])
{
CommandLineParser cmd(argc, argv,
"{ image i | ../data/pic1.png | input image }"
"{ template t | templ.png | template image }"
"{ full | | estimate scale and rotation }"
"{ gpu | | use gpu version }"
"{ minDist | 100 | minimum distance between the centers of the detected objects }"
"{ levels | 360 | R-Table levels }"
"{ votesThreshold | 30 | the accumulator threshold for the template centers at the detection stage. The smaller it is, the more false positions may be detected }"
"{ angleThresh | 10000 | angle votes treshold }"
"{ scaleThresh | 1000 | scale votes treshold }"
"{ posThresh | 100 | position votes threshold }"
"{ dp | 2 | inverse ratio of the accumulator resolution to the image resolution }"
"{ minScale | 0.5 | minimal scale to detect }"
"{ maxScale | 2 | maximal scale to detect }"
"{ scaleStep | 0.05 | scale step }"
"{ minAngle | 0 | minimal rotation angle to detect in degrees }"
"{ maxAngle | 360 | maximal rotation angle to detect in degrees }"
"{ angleStep | 1 | angle step in degrees }"
"{ maxBufSize | 1000 | maximal size of inner buffers }"
"{ help h ? | | print help message }"
);
cmd.about("This program demonstrates arbitary object finding with the Generalized Hough transform.");
if (cmd.has("help"))
{
cmd.printMessage();
return 0;
}
const string templName = cmd.get<string>("template");
const string imageName = cmd.get<string>("image");
const bool full = cmd.has("full");
const bool useGpu = cmd.has("gpu");
const double minDist = cmd.get<double>("minDist");
const int levels = cmd.get<int>("levels");
const int votesThreshold = cmd.get<int>("votesThreshold");
const int angleThresh = cmd.get<int>("angleThresh");
const int scaleThresh = cmd.get<int>("scaleThresh");
const int posThresh = cmd.get<int>("posThresh");
const double dp = cmd.get<double>("dp");
const double minScale = cmd.get<double>("minScale");
const double maxScale = cmd.get<double>("maxScale");
const double scaleStep = cmd.get<double>("scaleStep");
const double minAngle = cmd.get<double>("minAngle");
const double maxAngle = cmd.get<double>("maxAngle");
const double angleStep = cmd.get<double>("angleStep");
const int maxBufSize = cmd.get<int>("maxBufSize");
if (!cmd.check())
{
cmd.printErrors();
return -1;
}
Mat templ = loadImage(templName);
Mat image = loadImage(imageName);
Ptr<GeneralizedHough> alg;
if (!full)
{
Ptr<GeneralizedHoughBallard> ballard = useGpu ? cuda::createGeneralizedHoughBallard() : createGeneralizedHoughBallard();
ballard->setMinDist(minDist);
ballard->setLevels(levels);
ballard->setDp(dp);
ballard->setMaxBufferSize(maxBufSize);
ballard->setVotesThreshold(votesThreshold);
alg = ballard;
}
else
{
Ptr<GeneralizedHoughGuil> guil = useGpu ? cuda::createGeneralizedHoughGuil() : createGeneralizedHoughGuil();
guil->setMinDist(minDist);
guil->setLevels(levels);
guil->setDp(dp);
guil->setMaxBufferSize(maxBufSize);
guil->setMinAngle(minAngle);
guil->setMaxAngle(maxAngle);
guil->setAngleStep(angleStep);
guil->setAngleThresh(angleThresh);
guil->setMinScale(minScale);
guil->setMaxScale(maxScale);
guil->setScaleStep(scaleStep);
guil->setScaleThresh(scaleThresh);
guil->setPosThresh(posThresh);
alg = guil;
}
vector<Vec4f> position;
TickMeter tm;
if (useGpu)
{
cuda::GpuMat d_templ(templ);
cuda::GpuMat d_image(image);
cuda::GpuMat d_position;
alg->setTemplate(d_templ);
tm.start();
alg->detect(d_image, d_position);
d_position.download(position);
tm.stop();
}
else
{
alg->setTemplate(templ);
tm.start();
alg->detect(image, position);
tm.stop();
}
cout << "Found : " << position.size() << " objects" << endl;
cout << "Detection time : " << tm.getTimeMilli() << " ms" << endl;
Mat out;
cv::cvtColor(image, out, COLOR_GRAY2BGR);
for (size_t i = 0; i < position.size(); ++i)
{
Point2f pos(position[i][0], position[i][1]);
float scale = position[i][2];
float angle = position[i][3];
RotatedRect rect;
rect.center = pos;
rect.size = Size2f(templ.cols * scale, templ.rows * scale);
rect.angle = angle;
Point2f pts[4];
rect.points(pts);
line(out, pts[0], pts[1], Scalar(0, 0, 255), 3);
line(out, pts[1], pts[2], Scalar(0, 0, 255), 3);
line(out, pts[2], pts[3], Scalar(0, 0, 255), 3);
line(out, pts[3], pts[0], Scalar(0, 0, 255), 3);
}
imshow("out", out);
waitKey();
return 0;
}
void SuperRe()
{
Mat inputImg = imread(INPUTFILNAME, 1);
inputImg.convertTo(inputImg, CV_32FC3);
/*************************************color********/
//vector<Scalar> color;
//color.push_back(Scalar(255, 0, 0));//0
//color.push_back(Scalar(0, 255, 0));//1
//color.push_back(Scalar(0, 0, 255));//2
//color.push_back(Scalar(192, 0, 0));//3 dark red
//color.push_back(Scalar(255, 192, 0));//4 orange
//color.push_back(Scalar(255, 255, 0));//5 yellow
//color.push_back(Scalar(146, 208, 80));//6 green
//color.push_back(Scalar(0, 176, 80));//7 dark green
//color.push_back(Scalar(0, 176, 240));//8 blue
//color.push_back(Scalar(0, 112, 192));//9 dark blue
//color.push_back(Scalar(0, 32, 96));//dark blue
//color.push_back(Scalar(112, 48, 160));//dark pink
/****************************color*****************/
//Key = cvCreateMat(446508, 174, CV_32F);
TickMeter tm;
tm.start();
vector<Mat> CrCb;
draw = new Point2d*[inputImg.rows];
drawindex = new int*[inputImg.rows];
for (int n = 0; n < inputImg.rows; n++)
{
draw[n] = new Point2d[inputImg.cols];
drawindex[n] = new int[inputImg.cols];
for (int u = 0; u < inputImg.cols; u++)
{
drawindex[n][u] = 0;
}
}
/*float** data;
data = new float*[Key.rows];
for (int i = 0; i < Key.rows; i++){
data[i] = new float[Key.cols];
for (int j = 0; j < Key.cols; j++){
data[i][j] = -500.0;
}
}
for (int row = 0; row < Key.rows; row++)
{
for (int col = 0; col < Key.cols; col++)
{
data[row][col] = Key.at<float>(row, col);
}
}
WriteFile(Key.rows, Key.cols, data, KEY);
for (int i = 0; i < Key.rows; i++){
delete[]data[i];
}
delete[]data; */
/*******************************************/
//ifstream in(KEY);
//char line[10240];
//in.getline(line, 10240);
//cout << line;
//int lineno = 0;
//while (in.getline(line, 10240)){
// stringstream ss2;
// ss2 << line;
// for (int j = 0; j < 174; j++){
// ss2 >> Key.at<float>(lineno, j);// data[lineno][j];
// }
// lineno++;
//}
/*for (int row = 0; row < Key.rows; row++)
{
for (int col = 0; col < Key.cols; col++)
{
Key.at<float>(row, col) = data[row][col];
}
}*/
for (int row = 0; row < inputImg.rows; row++)
{
for (int col = 0; col < inputImg.cols; col++)
{
inputImg.at<Vec3f>(row, col)[0] = inputImg.at<Vec3f>(row, col)[0]/255.0;
inputImg.at<Vec3f>(row, col)[1] = inputImg.at<Vec3f>(row, col)[1] / 255.0;
inputImg.at<Vec3f>(row, col)[2] = inputImg.at<Vec3f>(row, col)[2] / 255.0;
}
}
Mat inputImage, Input, rycImg, temp, Cr, Cb, srcOfMerge, finalMerge,colorSrc;
colorSrc=inputImg.clone();
GaussianBlur(inputImg, inputImage, Size(7, 7), 1, 0.0, BORDER_REPLICATE);
resize(inputImage, Input, Size(inputImage.cols / 4, inputImage.rows / 4), 0, 0, CV_INTER_CUBIC);
imwrite(TEST + "inputImage.png", Input*255.0);
cvtColor(inputImg, rycImg, CV_BGR2YCrCb);
split(rycImg, CrCb);
Mat SrcImg = CrCb[0];
GaussianBlur(CrCb[1], CrCb[1], Size(7, 7), 1, 0.0, BORDER_REPLICATE);
resize(CrCb[1], temp, Size(inputImage.cols / 4, inputImage.rows / 4), 0, 0, CV_INTER_CUBIC);
resize(temp, CrCb[1], Size(inputImage.cols, inputImage.rows), 0, 0, CV_INTER_CUBIC);
GaussianBlur(CrCb[2], CrCb[2], Size(7, 7), 1, 0.0, BORDER_REPLICATE);
resize(CrCb[2], temp, Size(inputImage.cols / 4, inputImage.rows / 4), 0, 0, CV_INTER_CUBIC);
resize(temp, CrCb[2], Size(inputImage.cols, inputImage.rows), 0, 0, CV_INTER_CUBIC);
Mat lowResImg, highResImg, cubicImg, bandpass, AddDifference, blurImg;
GeneraLHImg(bandpass, highResImg, SrcImg, cubicImg);
lowResImg = bandpass + cubicImg;
Mat colorlowResImg, colorhighResImg, colorcubicImg, clorbandpass;
GeneraLHImg(clorbandpass, colorhighResImg, colorSrc, colorcubicImg);
colorlowResImg = clorbandpass + colorcubicImg;
imwrite(TEST + "inputcolorbandpass.png", colorlowResImg*255.0);
imwrite(TEST + "inputbandpass1.png", bandpass*255.0);
CrCb[0] = lowResImg.clone();
merge(CrCb, srcOfMerge);
cvtColor(srcOfMerge, finalMerge, CV_YCrCb2BGR);
imwrite(TEST + "inputlowpasscompa.png", finalMerge*255.0);
Mat foo = IMconstrast(bandpass, 3);
imwrite(TEST + "inputbandpasscn1.png", foo*255.0);
Mat abss = abs(foo);
Mat contrast(abss.rows, abss.cols, CV_32F);
float max = 0;
for (int r = 0; r < abss.rows; r++)
{
for (int c = 0; c < abss.cols; c++)
{
if (abss.at<float>(r, c)>max)
{
max = abss.at<float>(r, c);
}
}
}
for (int r = 0; r < abss.rows; r++)
{
for (int c = 0; c < abss.cols; c++)
{
float x = foo.at<float>(r, c);
float y = foo.at<float>(r, c) / (max + 0.5);
contrast.at<float>(r, c) = foo.at<float>(r, c) / (max + 0.5) + 0.5;
float z = contrast.at<float>(r, c);
float xx = 0;
}
}
imwrite(TEST + "inputbandpassContrast.png", contrast*225.0);
//Result.create(bandpass.rows, bandpass.cols, CV_32F);// Scalar::all(128));// ::zeros(lowResImg.rows, lowResImg.cols, CV_32FC3);R
//Result = bandpass.clone();// setTo(Scalar::all(0));
//Result = highResImg.clone();
Result = highResImg.clone();
Result.setTo(Scalar::all(0));
Mat testResult = Result.clone();
//Mat subResult = Result.clone();
cv::flann::Index kdtree(Key, cv::flann::KDTreeIndexParams(1));
int iterate_r = Result.rows - 6, iterate_c = Result.cols - 6;
vector<int> indices(1);
vector<float> dists(1);
vector<int>::iterator it;
map<int, float>::iterator it_map;
map<int, float> vectorList;
map<int, Point2d> testPoint;
ofstream fout("test.txt");
if (!fout)
{
cout << "File Not Opened" << endl; return;
}
int index = 0;
/**************************************/
/*ifstream in("E:\\testyy.txt");
int** data;
char line[10240];
in.getline(line, 10240);*/
/*int datanum = 0;
for (int r = 0; r < iterate_r; r = r + 4)
{
for (int c = 0; c < iterate_c; c = c + 4)
{
datanum++;
}
}*/
/**************************************/
//int rowr = 0;
////float** data;
//data = new float*[datanum];
//for (int i = 0; i < datanum; i++){
// data[i] = new float[174];
// for (int j = 0; j < 174; j++){
// data[i][j] = -500.0;
// }
//}
/**************************************/
for (int r = 0; r < iterate_r; r = r + 4)
{
/******************************/
//in.getline(line, 10240);
//stringstream ss2;
//ss2 << line;
/******************************/
for (int c = 0; c < iterate_c; c = c + 4)
{
Mat lowres = bandpass(Rect(c, r, 7, 7));
Mat colorlowres = clorbandpass(Rect(c, r, 7, 7));
Mat higres = Result(Rect(c + 1, r + 1, 5, 5));
Mat testrr = testResult(Rect(c + 1, r + 1, 5, 5));
//Mat subhigres = subResult(Rect(c + 1, r + 1, 5, 5));
Mat Output = cvCreateMat(1, 61, CV_32FC1);
int count = 0;
/*for (int channel = 0; channel < 3; channel++)
{*/
for (int row = 0; row < 7; row++)
{
for (int col = 0; col < 7; col++)
{
Output.at<float>(0, count) = lowres.at<float>(row, col);
count++;
}
}
for (int col = 0; col < 5; col++)
{
Output.at<float>(0, count) = higres.at<float>(0, col) * ALPHA;
count++;
}
for (int row = 1; row < 5; row++)
{
Output.at<float>(0, count) = higres.at<float>(row, 0) * ALPHA;
count++;
}
float * mean=new float[3];mean[0]=mean[1]=mean[2]=0;
for(int channel=0;channel<3;channel++)
{
for (int row = 0; row < 7; row++)
{
for (int col = 0; col < 7; col++)
{
float n0 = colorlowres.at<Vec3f>(row, col)[channel];
mean[channel]=n0+mean[channel];
}
}
mean[channel]=mean[channel]/49;
Output.at<float>(0, count) = mean[channel]*COLORCONS;
count++;
}
/*}*/
float x = MatMean(Output);
float result = Std(Output, x);
Output = Output / result;
/*for (int n = 0; n < 174; n++)
{
data[rowr][n] = Output.at<float>(0, n);
}
rowr++;*/
kdtree.knnSearch(Output, indices, dists, 1, cv::flann::SearchParams(32));
it = indices.begin();
index = *it;
int pic = InWhichPic(index);
if (pic == -1 || pic > traiNo)
{
int error = 0;
}
Point2d point = Valuse[index];
draw[c + 1][r + 1] = point;
drawindex[c + 1][r + 1] = pic;
int rh = -1, ch = 0;
for (int patch_r = point.x + 1; patch_r < point.x + 6; patch_r++)
{
rh++; ch = 0;
for (int patch_l = point.y + 1; patch_l < point.y + 6; patch_l++)
{
higres.at<float>(rh, ch) = ((InputHigh[pic].at<float>(patch_r, patch_l)) / HighMean[index])* result;
/*higres.at<Vec3f>(rh, ch)[1] = ((InputHigh[pic].at<Vec3f>(patch_r, patch_l)[1]) / HighMean[index])* result;
higres.at<Vec3f>(rh, ch)[2] = ((InputHigh[pic].at<Vec3f>(patch_r, patch_l)[2]) / HighMean[index])* result;*/
ch++;
}
}
//Mat temp=
/******************/
//ss2 >> index;
/******************/
vectorList.insert(make_pair(index, result));
testPoint.insert(make_pair(index,Point(c,r)));
//higres = Values[index] * result;
//Mat temp = Values(Rect(index, 0, 1, 25)); int cc = 0;
/*for (int row = 0; row < 5; row++)
{
for (int col = 0; col < 5; col++)
{
for (int n = 0; n < 3; n++)
{
higres.at<Vec3f>(row, col)[n] = temp.at<Vec3f>(0, cc)[n] * result;
}
cc++;
}
}*/
//higres = Values(Rect(index, 0, 1, 25))*result;
//if (r<20&&c<21)
//{
char temps[20];
sprintf(temps, "%d ", index);
string s(temps);
fout << s << " ";
/*}*/
}
/*if (r < 20)
{*/
fout << endl;
/*}*/
}
/*************************************/
/*WriteFile(3025, 174, data,OUTPUT);
for (int i = 0; i <3025; i++){
delete[]data[i];
}
delete[]data;*/
/*************************************/
Mat final, finalresult;
imwrite(TEST + "addOriginalResult.png", Result*255.0);
add(lowResImg, Result, Result);
imwrite(TEST + "addResult.png", Result*255.0);
CrCb[0] = Result;
merge(CrCb, finalresult);
cvtColor(finalresult, finalMerge, CV_YCrCb2BGR);
imwrite(TEST + "addfinalResult.png", finalMerge*255.0);
tm.stop();
cout << "count=" << tm.getCounter() << ",process time=" << tm.getTimeSec() << endl;
Sleep(5000);
/*******************test data*********/
Mat Finaltest = finalMerge*255.0;
vector<Mat> testInput;
Mat* inputest = new Mat[traiNo];
for (int i = 0; i < traiNo; i++)
{
inputest[i] = imread(TRAINFILENAME[i],1);
}
for (int i = 0; i < traiNo; i++)
{
Mat a = Mat::zeros(Finaltest.rows, Finaltest.cols + inputest[i].cols, CV_32FC3);
Finaltest.copyTo(a(Rect(0, 0, Finaltest.cols, Finaltest.rows)));
inputest[i].convertTo(inputest[i], CV_32FC3);
inputest[i].copyTo(a(Rect(Finaltest.cols, 0, inputest[i].cols, inputest[i].rows)));
testInput.push_back(a);
}
int *sumtemp = new int[traiNo];
for (int n = 0; n < traiNo; n++)
{
sumtemp[n] = 0;
}
int width = inputImage.cols, height = inputImage.rows;
map<int, Point2d>::iterator itest;
itest = testPoint.begin();
for (it_map = vectorList.begin(); it_map != vectorList.end(); it_map++)
{
int index = it_map->first;
Point2d a = itest->second;
int pic = InWhichPic(index);
sumtemp[pic]++;
Point2d point = Valuse[index];
Point b = Point(a.x + 5, a.y + 5);
Point a1 = Point(point.x + 1 + inputImg.cols, point.y + 1);
Point b1 = Point(point.x + 5 + inputImg.cols, point.y + 5);
rectangle(testInput[pic], a, b, Scalar(a.y * 255 / height, 0, a.x * 255 / width), 1, 8);
rectangle(testInput[pic], a1, b1, Scalar(a.y * 255 / height, 0, a.x * 255 / width), 1, 8);
//line(testInput[pic], a, a1, Scalar(255, 0, 0), 0.1, 8);
itest++;
}
for (int i = 0; i < traiNo; i++)
{
char temps[20];
sprintf(temps, "test_%d.png", i);
string s(temps);
imwrite(TEST + temps, testInput[i]);
}
WriteINTFile(inputImage.rows, inputImage.cols, drawindex, INDEX);
WritePOINTFile(inputImage.rows, inputImage.cols, draw, POINTfile);
for (int n = 0; n < traiNo; n++)
{
fout << sumtemp[n] << endl;
}
fout.close();
/******************test data**********/
//CrCb.clear();
vectorList.clear();
/*cvMerge(Y, Cr, Cb, NULL, frame)
cvtColor(frame, frame, CV_YCrCb2BGR)*/
}
void TaskManager::run(string groundTruthFile)
{
//run on the train data or on the test data
bool useGroundTruth = !groundTruthFile.empty();
cout << "Processing from " << from << " to " << to << endl << endl;
answers.clear();
Answers::type rightAnswers;
if (useGroundTruth)
{
Answers::loadAnswers(groundTruthFile, rightAnswers);
const int inlierLabel = 0;
vector<int> fullPanoramaMask(images_count, inlierLabel);
for (int i = from; i <= to; ++i)
if (rightAnswers.find(i) == rightAnswers.end())
rightAnswers.insert(make_pair(i, fullPanoramaMask));
}
int total = to - from + 1;
vector < vector<KruskalGrouper::Grouping> > groupings(total);
float minIncorrectDistance = std::numeric_limits<float>::max();
int minIncorrectDistanceSeriaIdx = -1;
#pragma omp parallel for schedule(dynamic, 5)
for (int i = from; i <= to; ++i)
{
cout << "Seria #" << i << "\t" << endl;
TickMeter time;
time.start();
OnePanoSolver solver(folder, i, cache_folder);
Mat diff;
#if 0 // cross-check only
bool found = solver.launch(groupings[i - from], diff, int());
#else
solver.launch(groupings[i - from], diff);
#endif
time.stop();
cout << "Time: " << time.getTimeSec() << "s" << endl;
if (useGroundTruth)
{
vector<int> right = rightAnswers[i];
for (int j = 0; j < diff.rows; j++)
{
for (int k = j + 1; k < diff.cols; k++)
{
if (right[j] != right[k])
{
CV_Assert(diff.type() == CV_32FC1);
if (diff.at<float> (j, k) <= minIncorrectDistance)
{
minIncorrectDistance = diff.at<float> (j, k);
minIncorrectDistanceSeriaIdx = i;
}
}
}
}
}
}
int bestScore = -1;
double bestThreshold = -1;
const int minPanoSize = 3;
if (useGroundTruth)
{
for (size_t i = 0; i < groupings.size(); i++)
{
int curBestScore = -1;
double curBestThreshold = -1;
for (size_t j = 1; j < groupings[i].size() - 1; j++)
{
double curThreshold = groupings[i][j].threshold;
int curScore = 0;
for (size_t k = 0; k < groupings.size(); k++)
{
vector<int> classes, answer_mask;
KruskalGrouper::group(groupings[k], curThreshold, minPanoSize, classes);
stringstream devNull;
generateOutputMaskFromClasses(classes, answer_mask, devNull);
int score = static_cast<int>(images_count - norm(Mat(answer_mask) - Mat(rightAnswers[from + k]), NORM_L1));
curScore += score;
}
if (curScore > curBestScore)
{
curBestScore = curScore;
curBestThreshold = curThreshold;
}
}
if (curBestScore > bestScore)
{
bestScore = curBestScore;
bestThreshold = curBestThreshold;
}
}
}
else
{
bestThreshold = 0.3;
}
for (size_t k = 0; k < groupings.size(); k++)
{
vector<int> classes;
KruskalGrouper::group(groupings[k], bestThreshold, minPanoSize, classes);
stringstream devNull;
generateOutputMaskFromClasses(classes, answers[k + from], devNull);
}
}
int getFeaturePyramid(IplImage * image, CvLSVMFeaturePyramid **maps,
const int bx, const int by)
{
IplImage *imgResize;
float step;
unsigned int numStep;
unsigned int maxNumCells;
unsigned int W, H;
if (image->depth == IPL_DEPTH_32F)
{
imgResize = image;
}
else
{
imgResize = cvCreateImage(cvSize(image->width, image->height),
IPL_DEPTH_32F, 3);
cvConvert(image, imgResize);
}
W = imgResize->width;
H = imgResize->height;
step = powf(2.0f, 1.0f / ((float) Lambda));
maxNumCells = W / Side_Length;
if (maxNumCells > H / Side_Length)
{
maxNumCells = H / Side_Length;
}
numStep = (int) (logf((float) maxNumCells / (5.0f)) / logf(step)) + 1;
allocFeaturePyramidObject(maps, numStep + Lambda);
#ifdef PROFILE
TickMeter tm;
tm.start();
cout << "(featurepyramid.cpp)getPathOfFeaturePyramid START " << endl;
#endif
uploadImageToGPU1D(imgResize);
getPathOfFeaturePyramidGPUStream(imgResize, step , Lambda, 0,
Side_Length / 2, bx, by, maps);
getPathOfFeaturePyramidGPUStream(imgResize, step, numStep, Lambda,
Side_Length , bx, by, maps);
cleanImageFromGPU1D();
#ifdef PROFILE
tm.stop();
cout << "(featurepyramid.cpp)getPathOfFeaturePyramid END time = "
<< tm.getTimeSec() << " sec" << endl;
#endif
if (image->depth != IPL_DEPTH_32F)
{
cvReleaseImage(&imgResize);
}
return LATENT_SVM_OK;
}
int main(int argc, char** argv)
{
// Init CUDA
cudaFree(0);
int device;
cudaGetDevice(&device);
cudaSetDevice(device);
float vals[] = {525., 0., 3.1950000000000000e+02,
0., 525., 2.3950000000000000e+02,
0., 0., 1.};
/*
float vals[] = {523.56375, 0., 3.2203666e+02,
0., 523.34835, 2.3144145e+02,
0., 0., 1.};
*/
const Mat cameraMatrix = Mat(3,3,CV_32FC1,vals);
const Mat distCoeff(1,5,CV_32FC1,Scalar(0));
if( argc != 5 && argc != 6 )
{
cout << "Format: image0 depth0 image1 depth1 [transformationType]" << endl;
cout << "Depth file must be 16U image stored depth in mm." << endl;
cout << "Transformation types:" << endl;
cout << " -rbm - rigid body motion (default)" << endl;
cout << " -r - rotation rotation only" << endl;
cout << " -t - translation only" << endl;
return -1;
}
Mat colorImage0 = imread( argv[1] );
Mat depth0 = imread( argv[2], -1 );
Mat colorImage1 = imread( argv[3] );
Mat depth1 = imread( argv[4], -1 );
if( colorImage0.empty() || depth0.empty() || colorImage1.empty() || depth1.empty() )
{
cout << "Data (rgb or depth images) is empty.";
return -1;
}
int transformationType = RIGID_BODY_MOTION;
if( argc == 6 )
{
string ttype = argv[5];
if( ttype == "-rbm" )
{
transformationType = RIGID_BODY_MOTION;
}
else if ( ttype == "-r")
{
transformationType = ROTATION;
}
else if ( ttype == "-t")
{
transformationType = TRANSLATION;
}
else
{
cout << "Unsupported transformation type." << endl;
return -1;
}
}
Mat grayImage0, grayImage1, depthFlt0, depthFlt1/*in meters*/;
cvtColor( colorImage0, grayImage0, COLOR_BGR2GRAY );
cvtColor( colorImage1, grayImage1, COLOR_BGR2GRAY );
depth0.convertTo( depthFlt0, CV_32FC1, 1./1000 );
depth1.convertTo( depthFlt1, CV_32FC1, 1./1000 );
TickMeter tm;
Mat Rt;
vector<int> iterCounts(4);
iterCounts[0] = 7;
iterCounts[1] = 7;
iterCounts[2] = 7;
iterCounts[3] = 10;
vector<float> minGradMagnitudes(4);
minGradMagnitudes[0] = 12;
minGradMagnitudes[1] = 5;
minGradMagnitudes[2] = 3;
minGradMagnitudes[3] = 1;
const float minDepth = 0.f; //in meters
const float maxDepth = 4.f; //in meters
const float maxDepthDiff = 0.07f; //in meters
tm.start();
/*
bool isFound = cv::RGBDOdometry( Rt, Mat(),
grayImage0, depthFlt0, Mat(),
grayImage1, depthFlt1, Mat(),
cameraMatrix, minDepth, maxDepth, maxDepthDiff,
iterCounts, minGradMagnitudes, transformationType );
*/
int repeat = 50;
bool isFound;
for (int i=0; i<repeat; ++i)
isFound = RGBDOdometry418( Rt, Mat(),
grayImage0, depthFlt0, Mat(),
grayImage1, depthFlt1, Mat(),
cameraMatrix, minDepth, maxDepth, maxDepthDiff,
iterCounts, minGradMagnitudes, transformationType );
tm.stop();
cout << "Rt = " << Rt << endl;
cout << "Time = " << tm.getTimeSec()/repeat << " sec." << endl;
if( !isFound )
{
cout << "Rigid body motion cann't be estimated for given RGBD data." << endl;
return -1;
}
Mat warpedImage0;
warpImage<Point3_<uchar> >( colorImage0, depthFlt0, Rt, cameraMatrix, distCoeff, warpedImage0 );
imshow( "image0", colorImage0 );
imshow( "warped_image0", warpedImage0 );
imwrite("warped.png", warpedImage0);
imshow( "image1", colorImage1 );
waitKey();
return 0;
}
int main( int argc, const char **argv )
{
CommandLineParser parser( argc, argv, keys );
parser.about( "Global Patch Collider evaluation tool" );
if ( parser.has( "help" ) )
{
parser.printMessage();
return 0;
}
String fromPath = parser.get< String >( 0 );
String toPath = parser.get< String >( 1 );
String gtPath = parser.get< String >( 2 );
String outPath = parser.get< String >( 3 );
const bool useOpenCL = parser.has( "gpu" );
String forestDumpPath = parser.get< String >( "forest" );
if ( !parser.check() )
{
parser.printErrors();
return 1;
}
if ( !fileProbe( forestDumpPath.c_str() ) )
{
std::cerr << "Can't open the file with a trained model: `" << forestDumpPath
<< "`.\nYou can obtain this file either by manually training the model using another tool with *_train suffix or by "
"downloading one of the files trained on some publicly available dataset from "
"here:\nhttps://drive.google.com/open?id=0B7Hb8cfuzrIIZDFscXVYd0NBNFU"
<< std::endl;
return 1;
}
ocl::setUseOpenCL( useOpenCL );
Ptr< optflow::GPCForest< nTrees > > forest = Algorithm::load< optflow::GPCForest< nTrees > >( forestDumpPath );
Mat from = imread( fromPath );
Mat to = imread( toPath );
Mat gt = optflow::readOpticalFlow( gtPath );
std::vector< std::pair< Point2i, Point2i > > corr;
TickMeter meter;
meter.start();
forest->findCorrespondences( from, to, corr, optflow::GPCMatchingParams( useOpenCL ) );
meter.stop();
std::cout << "Found " << corr.size() << " matches." << std::endl;
std::cout << "Time: " << meter.getTimeSec() << " sec." << std::endl;
double error = 0;
Mat dispErr = Mat::zeros( from.size(), CV_32FC3 );
dispErr = Scalar( 0, 0, 1 );
Mat disp = Mat::zeros( from.size(), CV_32FC3 );
disp = Scalar( 0, 0, 1 );
for ( size_t i = 0; i < corr.size(); ++i )
{
const Point2f a = corr[i].first;
const Point2f b = corr[i].second;
const Point2f c = a + gt.at< Point2f >( corr[i].first.y, corr[i].first.x );
error += normL2( b - c );
circle( disp, a, 3, getFlowColor( b - a ), -1 );
circle( dispErr, a, 3, getFlowColor( b - c, false, 32 ), -1 );
}
error /= corr.size();
std::cout << "Average endpoint error: " << error << " px." << std::endl;
cvtColor( disp, disp, COLOR_HSV2BGR );
cvtColor( dispErr, dispErr, COLOR_HSV2BGR );
Mat dispGroundTruth;
displayFlow( gt, dispGroundTruth );
if ( outPath.length() )
{
putText( disp, "Sparse matching: Global Patch Collider", Point2i( 24, 40 ), FONT_HERSHEY_DUPLEX, 1, Vec3b( 1, 0, 0 ), 2, LINE_AA );
char buf[256];
sprintf( buf, "Average EPE: %.2f", error );
putText( disp, buf, Point2i( 24, 80 ), FONT_HERSHEY_DUPLEX, 1, Vec3b( 1, 0, 0 ), 2, LINE_AA );
sprintf( buf, "Number of matches: %u", (unsigned)corr.size() );
putText( disp, buf, Point2i( 24, 120 ), FONT_HERSHEY_DUPLEX, 1, Vec3b( 1, 0, 0 ), 2, LINE_AA );
disp *= 255;
imwrite( outPath, disp );
return 0;
}
namedWindow( "Correspondences", WINDOW_AUTOSIZE );
imshow( "Correspondences", disp );
namedWindow( "Error", WINDOW_AUTOSIZE );
imshow( "Error", dispErr );
namedWindow( "Ground truth", WINDOW_AUTOSIZE );
imshow( "Ground truth", dispGroundTruth );
waitKey( 0 );
return 0;
}
int main(int argc, const char* argv[])
{
if (argc != 2)
{
std::cerr << "Usage : video_writer <input video file>" << std::endl;
return -1;
}
const double FPS = 25.0;
cv::VideoCapture reader(argv[1]);
if (!reader.isOpened())
{
std::cerr << "Can't open input video file" << std::endl;
return -1;
}
cv::cuda::printShortCudaDeviceInfo(cv::cuda::getDevice());
cv::VideoWriter writer;
cv::Ptr<cv::cudacodec::VideoWriter> d_writer;
cv::Mat frame;
cv::cuda::GpuMat d_frame;
std::vector<double> cpu_times;
std::vector<double> gpu_times;
TickMeter tm;
for (int i = 1;; ++i)
{
std::cout << "Read " << i << " frame" << std::endl;
reader >> frame;
if (frame.empty())
{
std::cout << "Stop" << std::endl;
break;
}
if (!writer.isOpened())
{
std::cout << "Frame Size : " << frame.cols << "x" << frame.rows << std::endl;
std::cout << "Open CPU Writer" << std::endl;
if (!writer.open("output_cpu.avi", cv::VideoWriter::fourcc('X', 'V', 'I', 'D'), FPS, frame.size()))
return -1;
}
if (d_writer.empty())
{
std::cout << "Open CUDA Writer" << std::endl;
const cv::String outputFilename = "output_gpu.avi";
d_writer = cv::cudacodec::createVideoWriter(outputFilename, frame.size(), FPS);
}
d_frame.upload(frame);
std::cout << "Write " << i << " frame" << std::endl;
tm.reset(); tm.start();
writer.write(frame);
tm.stop();
cpu_times.push_back(tm.getTimeMilli());
tm.reset(); tm.start();
d_writer->write(d_frame);
tm.stop();
gpu_times.push_back(tm.getTimeMilli());
}
std::cout << std::endl << "Results:" << std::endl;
std::sort(cpu_times.begin(), cpu_times.end());
std::sort(gpu_times.begin(), gpu_times.end());
double cpu_avg = std::accumulate(cpu_times.begin(), cpu_times.end(), 0.0) / cpu_times.size();
double gpu_avg = std::accumulate(gpu_times.begin(), gpu_times.end(), 0.0) / gpu_times.size();
std::cout << "CPU [XVID] : Avg : " << cpu_avg << " ms FPS : " << 1000.0 / cpu_avg << std::endl;
std::cout << "GPU [H264] : Avg : " << gpu_avg << " ms FPS : " << 1000.0 / gpu_avg << std::endl;
return 0;
}
int main(int argc, char **argv)
{
std::system("date");
if (argc != 4)
{
cout << argv[0] << " <modelsPath> <baseFoldler> <testObjectName>" << endl;
return -1;
}
string modelsPath = argv[1];
string baseFolder = argv[2];
string testObjectName = argv[3];
//const string modelFilename = "finalModels/" + objectName + ".xml";
const string testFolder = baseFolder + "/" + testObjectName + "/";
// const string camerasListFilename = baseFolder + "/cameras.txt";
const string kinectCameraFilename = baseFolder + "/center.yml";
// const string visualizationPath = "visualized_results/";
const string errorsVisualizationPath = "/home/ilysenkov/errors/";
// const vector<string> objectNames = {"bank", "bucket"};
// const vector<string> objectNames = {"bank", "bottle", "bucket", "glass", "wineglass"};
const string registrationMaskFilename = baseFolder + "/registrationMask.png";
const vector<string> objectNames = {testObjectName};
TODBaseImporter dataImporter(testFolder);
PinholeCamera kinectCamera;
if(!kinectCameraFilename.empty())
{
dataImporter.readCameraParams(kinectCameraFilename, kinectCamera, false);
CV_Assert(kinectCamera.imageSize == Size(640, 480));
}
vector<EdgeModel> edgeModels(objectNames.size());
for (size_t i = 0; i < objectNames.size(); ++i)
{
dataImporter.importEdgeModel(modelsPath, objectNames[i], edgeModels[i]);
cout << "All points in the model: " << edgeModels[i].points.size() << endl;
cout << "Surface points in the model: " << edgeModels[i].stableEdgels.size() << endl;
EdgeModel::computeSurfaceEdgelsOrientations(edgeModels[i]);
}
vector<EdgeModel> occlusionObjects;
vector<PoseRT> occlusionOffsets;
dataImporter.importOcclusionObjects(modelsPath, occlusionObjects, occlusionOffsets);
//#ifdef VISUALIZE_POSE_REFINEMENT
// edgeModels[0].visualize();
//#endif
DetectorParams params;
// params.glassSegmentationParams.closingIterations = 8;
// bucket
// params.glassSegmentationParams.openingIterations = 8;
//good clutter
params.glassSegmentationParams.openingIterations = 15;
params.glassSegmentationParams.closingIterations = 12;
params.glassSegmentationParams.finalClosingIterations = 32;
params.glassSegmentationParams.grabCutErosionsIterations = 4;
params.planeSegmentationMethod = FIDUCIALS;
//fixedOnTable
//params.glassSegmentationParams.finalClosingIterations = 8;
//clutter
//bucket
//params.glassSegmentationParams.finalClosingIterations = 12;
Detector detector(kinectCamera, params);
// TransparentDetector detector(kinectCamera);
for (size_t i = 0; i < edgeModels.size(); ++i)
{
detector.addTrainObject(objectNames[i], edgeModels[i]);
}
vector<int> testIndices;
dataImporter.importTestIndices(testIndices);
Mat registrationMask = imread(registrationMaskFilename, CV_LOAD_IMAGE_GRAYSCALE);
CV_Assert(!registrationMask.empty());
vector<size_t> initialPoseCount;
vector<PoseError> bestPoses, bestInitialPoses;
int segmentationFailuresCount = 0;
int badSegmentationCount = 0;
vector<float> allChamferDistances;
vector<size_t> geometricHashingPoseCount;
// vector<int> indicesOfRecognizedObjects;
vector<double> allRecognitionTimes;
for(size_t testIdx = 0; testIdx < testIndices.size(); testIdx++)
{
srand(42);
RNG &rng = theRNG();
rng.state = 0xffffffff;
#if defined(VISUALIZE_POSE_REFINEMENT) && defined(USE_3D_VISUALIZATION)
boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(new pcl::visualization::PCLVisualizer ("transparent experiments"));
#endif
int testImageIdx = testIndices[ testIdx ];
cout << "Test: " << testIdx << " " << testImageIdx << endl;
Mat kinectDepth, kinectBgrImage;
if(!kinectCameraFilename.empty())
{
dataImporter.importBGRImage(testImageIdx, kinectBgrImage);
dataImporter.importDepth(testImageIdx, kinectDepth);
}
/*
Mat silhouetteImage(480, 640, CV_8UC1, Scalar(0));
silhouettes[0].draw(silhouetteImage);
imshow("silhouette", silhouetteImage);
imshow("mask", centerMask);
waitKey();
vector<Point2f> glassContour;
mask2contour(centerMask, glassContour);
Mat silhouette2test;
silhouettes[0].match(Mat(glassContour), silhouette2test);
exit(-1);
*/
PoseRT model2test_fiducials, objectOffset;
dataImporter.importGroundTruth(testImageIdx, model2test_fiducials, false, &objectOffset);
PoseRT model2test_ground = model2test_fiducials * objectOffset;
// cout << "Ground truth: " << model2test_ground << endl;
CV_Assert(edgeModels.size() == 1);
float occlusionPercentage = computeOcclusionPercentage(kinectCamera, edgeModels[0], objectOffset, occlusionObjects, occlusionOffsets, model2test_fiducials);
CV_Assert(0.0 <= occlusionPercentage && occlusionPercentage <= 1.0);
cout << "occlusion percentage: " << occlusionPercentage << endl;
pcl::PointCloud<pcl::PointXYZ> testPointCloud;
#ifdef USE_3D_VISUALIZATION
dataImporter.importPointCloud(testImageIdx, testPointCloud);
#endif
#ifdef VISUALIZE_TEST_DATA
imshow("rgb", kinectBgrImage);
imshow("depth", kinectDepth * 20);
#endif
#ifdef VISUALIZE_POSE_REFINEMENT
#ifdef USE_3D_VISUALIZATION
{
vector<Point3f> cvTestPointCloud;
pcl2cv(testPointCloud, cvTestPointCloud);
cout << "test point cloud size: " << cvTestPointCloud.size() << endl;
publishPoints(cvTestPointCloud, viewer, Scalar(0, 255, 0), "test point cloud");
}
publishPoints(edgeModels[0].points, viewer, Scalar(0, 0, 255), "ground object", model2test_ground);
#endif
if(!kinectCameraFilename.empty())
{
// displayEdgels(glassMask, edgeModels[0].points, model2test_ground, kinectCamera, "kinect");
showEdgels(kinectBgrImage, edgeModels[0].points, model2test_ground, kinectCamera, "ground truth");
showEdgels(kinectBgrImage, edgeModels[0].stableEdgels, model2test_ground, kinectCamera, "ground truth surface");
}
namedWindow("ground truth");
#ifdef USE_3D_VISUALIZATION
while (!viewer->wasStopped ())
{
viewer->spinOnce (100);
boost::this_thread::sleep (boost::posix_time::microseconds (100000));
}
viewer->resetStoppedFlag();
#endif
waitKey();
destroyWindow("ground truth");
#endif
vector<PoseRT> poses_cam;
vector<float> posesQualities;
vector<string> detectedObjectsNames;
TickMeter recognitionTime;
recognitionTime.start();
Detector::DebugInfo debugInfo;
try
{
detector.detect(kinectBgrImage, kinectDepth, registrationMask, testPointCloud, poses_cam, posesQualities, detectedObjectsNames, &debugInfo);
}
catch(const cv::Exception &)
{
}
recognitionTime.stop();
#ifdef VISUALIZE_POSE_REFINEMENT
Mat glassMask = debugInfo.glassMask;
imshow("glassMask", glassMask);
showSegmentation(kinectBgrImage, glassMask, "segmentation");
Mat detectionResults = kinectBgrImage.clone();
detector.visualize(poses_cam, detectedObjectsNames, detectionResults);
imshow("detection", detectionResults);
waitKey();
#endif
#ifndef PROFILE
if (edgeModels.size() == 1)
{
vector<Point2f> groundEdgels;
kinectCamera.projectPoints(edgeModels[0].points, model2test_ground, groundEdgels);
vector<float> chamferDistances;
for (size_t silhouetteIndex = 0; silhouetteIndex < debugInfo.initialSilhouettes.size(); ++silhouetteIndex)
{
vector<Point2f> silhouette = debugInfo.initialSilhouettes[silhouetteIndex];
double silhoutteDistance = 0.0;
for (int i = 0; i < silhouette.size(); ++i)
{
float minDist = std::numeric_limits<float>::max();
for (int j = 0; j < groundEdgels.size(); ++j)
{
float currentDist = norm(silhouette[i] - groundEdgels[j]);
if (currentDist < minDist)
{
minDist = currentDist;
}
}
silhoutteDistance += minDist;
}
silhoutteDistance /= silhouette.size();
chamferDistances.push_back(silhoutteDistance);
}
std::sort(chamferDistances.begin(), chamferDistances.end());
if (chamferDistances.empty())
{
chamferDistances.push_back(std::numeric_limits<float>::max());
}
cout << "Best geometric hashing pose (px): " << chamferDistances[0] << endl;
cout << "Number of initial poses: " << chamferDistances.size() << endl;
allChamferDistances.push_back(chamferDistances[0]);
geometricHashingPoseCount.push_back(chamferDistances.size());
}
if (poses_cam.size() == 0)
{
++segmentationFailuresCount;
continue;
}
if (!posesQualities.empty())
{
std::vector<float>::iterator bestDetection = std::min_element(posesQualities.begin(), posesQualities.end());
int bestDetectionIndex = std::distance(posesQualities.begin(), bestDetection);
// int detectedObjectIndex = detector.getTrainObjectIndex(detectedObjectsNames[bestDetectionIndex]);
// indicesOfRecognizedObjects.push_back(detectedObjectIndex);
cout << "Recognized object: " << detectedObjectsNames[bestDetectionIndex] << endl;
}
cout << "Recognition time: " << recognitionTime.getTimeSec() << "s" << endl;
allRecognitionTimes.push_back(recognitionTime.getTimeSec());
if (objectNames.size() == 1)
{
cout << "initial poses: " << debugInfo.initialPoses.size() << endl;
vector<PoseError> initialPoseErrors;
for (size_t i = 0 ; i < debugInfo.initialPoses.size(); ++i)
{
PoseError poseError;
evaluatePoseWithRotation(edgeModels[0], debugInfo.initialPoses[i], model2test_ground, poseError);
cout << poseError << endl;
initialPoseErrors.push_back(poseError);
// showEdgels(kinectBgrImage, edgeModels[0].points, debugInfo.initialPoses[i], kinectCamera, "gh pose");
// waitKey();
}
cout << "the end." << endl;
PoseError currentBestInitialError;
{
vector<PoseError>::iterator bestPoseIt = std::min_element(initialPoseErrors.begin(), initialPoseErrors.end());
int bestPoseIdx = std::distance(initialPoseErrors.begin(), bestPoseIt);
currentBestInitialError = initialPoseErrors[bestPoseIdx];
cout << "Best initial error: " << currentBestInitialError << endl;
bestInitialPoses.push_back(currentBestInitialError);
}
CV_Assert(poses_cam.size() == 1);
int objectIndex = 0;
initialPoseCount.push_back(poses_cam.size());
vector<PoseError> currentPoseErrors(poses_cam.size());
for (size_t i = 0 ; i < poses_cam.size(); ++i)
{
evaluatePoseWithRotation(edgeModels[objectIndex], poses_cam[i], model2test_ground, currentPoseErrors[i]);
cout << currentPoseErrors[i] << endl;
#ifdef VISUALIZE_POSE_REFINEMENT
namedWindow("pose is ready");
waitKey();
destroyWindow("pose is ready");
// displayEdgels(glassMask, edgeModels[objectIndex].points, initPoses_cam[objectIndex][i], kinectCamera, "initial");
#ifdef USE_3D_VISUALIZATION
publishPoints(edgeModels[objectIndex].points, viewer, Scalar(255, 0, 0), "final object", poses_cam[i]);
#endif
showEdgels(kinectBgrImage, edgeModels[objectIndex].points, poses_cam[i], kinectCamera, "final");
showEdgels(kinectBgrImage, edgeModels[objectIndex].stableEdgels, poses_cam[i], kinectCamera, "final surface");
namedWindow("initial pose");
#ifdef USE_3D_VISUALIZATION
while (!viewer->wasStopped ())
{
viewer->spinOnce (100);
boost::this_thread::sleep (boost::posix_time::microseconds (100000));
}
#endif
waitKey();
destroyWindow("initial pose");
#endif
}
vector<PoseError>::iterator bestPoseIt = std::min_element(currentPoseErrors.begin(), currentPoseErrors.end());
int bestPoseIdx = std::distance(currentPoseErrors.begin(), bestPoseIt);
PoseError currentBestError = currentPoseErrors[bestPoseIdx];
cout << "Best pose: " << currentBestError << endl;
bestPoses.push_back(currentBestError);
cout << "Result: " << occlusionPercentage << ", " << debugInfo.initialPoses.size() << ", " <<
currentBestInitialError.getTranslationDifference() << ", " << currentBestInitialError.getRotationDifference(false) << ", " <<
currentBestError.getTranslationDifference() << ", " << currentBestError.getRotationDifference(false) << endl;
#ifdef WRITE_ERRORS
const float maxTrans = 0.02;
if (currentPoseErrors[bestPoseIdx].getTranslationDifference() > maxTrans)
{
Mat glassMask = debugInfo.glassMask;
std::stringstream str;
str << testImageIdx;
Mat segmentation = drawSegmentation(kinectBgrImage, glassMask);
imwrite(errorsVisualizationPath + "/" + objectNames[0] + "_" + str.str() + "_mask.png", segmentation);
Mat poseImage = kinectBgrImage.clone();
detector.visualize(poses_cam, detectedObjectsNames, poseImage);
imwrite(errorsVisualizationPath + "/" + objectNames[0] + "_" + str.str() + "_pose.png", poseImage);
const float depthNormalizationFactor = 100;
imwrite(errorsVisualizationPath + "/" + objectNames[0] + "_" + str.str() + "_depth.png", kinectDepth * depthNormalizationFactor);
}
#endif
}
#endif
cout << endl;
#ifdef PROFILE
return 0;
#endif
}
cout << "Segmentation failures: " << static_cast<float>(segmentationFailuresCount) / testIndices.size() << endl;
cout << "Bad segmentation rate: " << static_cast<float>(badSegmentationCount) / testIndices.size() << endl;
/*
cout << "Recognition statistics:" << endl;
for (size_t i = 0; i < objectNames.size(); ++i)
{
cout << countNonZero(Mat(indicesOfRecognizedObjects) == i) << " ";
}
cout << endl;
for (size_t i = 0; i < objectNames.size(); ++i)
{
cout << countNonZero(Mat(indicesOfRecognizedObjects) == i) / static_cast<float>(indicesOfRecognizedObjects.size()) << " ";
}
cout << endl;
*/
if (objectNames.size() == 1)
{
float meanInitialPoseCount = std::accumulate(initialPoseCount.begin(), initialPoseCount.end(), 0);
meanInitialPoseCount /= initialPoseCount.size();
cout << "mean initial pose count: " << meanInitialPoseCount << endl;
//TODO: move up
const double cmThreshold = 2.0;
// const double cmThreshold = 5.0;
PoseError::evaluateErrors(bestPoses, cmThreshold);
cout << "initial poses:" << endl;
//TODO: move up
PoseError::evaluateErrors(bestInitialPoses, 3.0 * cmThreshold);
}
cout << "Evaluation of geometric hashing" << endl;
std::sort(allChamferDistances.begin(), allChamferDistances.end());
const float successfulChamferDistance = 5.0f;
int ghSuccessCount = 0;
double meanChamferDistance = 0.0;
for (size_t i = 0; i < allChamferDistances.size(); ++i)
{
cout << i << "\t: " << allChamferDistances[i] << endl;
if (allChamferDistances[i] < successfulChamferDistance)
{
++ghSuccessCount;
meanChamferDistance += allChamferDistances[i];
}
}
if (ghSuccessCount != 0)
{
meanChamferDistance /= ghSuccessCount;
}
int posesSum = std::accumulate(geometricHashingPoseCount.begin(), geometricHashingPoseCount.end(), 0);
float meanInitialPoseCount = static_cast<float>(posesSum) / initialPoseCount.size();
cout << "Mean number of initial poses: " << meanInitialPoseCount << endl;
float ghSuccessRate = static_cast<float>(ghSuccessCount) / allChamferDistances.size();
cout << "Success rate: " << ghSuccessRate << endl;
cout << "Mean chamfer distance (px): " << meanChamferDistance << endl;
double timesSum = std::accumulate(allRecognitionTimes.begin(), allRecognitionTimes.end(), 0.0);
double meanRecognitionTime = timesSum / allRecognitionTimes.size();
cout << "Mean recognition time (s): " << meanRecognitionTime << endl;
std::system("date");
return 0;
}
int main()
{
// Dataset Voc
string dir = "../DataSet/VOC2012/";
// string dir = "../DataSet/VOC2007/";
DataSetVOC voc(dir, false, true);
voc.loadAnnotations();
const size_t testNum = voc.testSet.size();
const char* imgPath =_S(voc.imgPathW);
// LSVM DPM
std::string dpmPersonModel = "../ExtraData/latentsvmXml/person.xml";
std::vector<std::string> models;
models.push_back(dpmPersonModel);
QUniLsvmDetector detector(models);
float overlapThreshold = 0.2f;
size_t imageCount = 0;
size_t personCount = 0;
size_t matchCount = 0;
vector<ScoreTp> pScores;
TickMeter tm;
for (int i = 0; i < testNum; i++){
const vector<Vec4i> &boxesGT = voc.gtTestBoxes[i];
const size_t gtNumCrnt = boxesGT.size();
if (gtNumCrnt <= 0)
continue;
imageCount++;
personCount += gtNumCrnt;
Mat image = imread(format(imgPath, _S(voc.testSet[i])));
tm.start();
vector<QUniLsvmDetector::ObjectDetection> detections;
detector.setup(image, overlapThreshold);
// No threading, nearly original LSVM
vector<FeatureMapCoord> ftrMapCoords;
vector<vector<FeatureMapCoord> *> fmcss;
fmcss.push_back(&ftrMapCoords);
detector.genFullFtrMapCoord(&ftrMapCoords);
detector.detect(detections, fmcss);
tm.stop();
vector<DetectedInfo> di(detections.size());
vector<int> gtIdx(gtNumCrnt, -1);
int detectCount = 0;
for (size_t j = 0; j < detections.size(); j++) {
const QUniLsvmDetector::ObjectDetection& od = detections[j];
if (od.score < RECOMMENDABLE_THRESHOLD)
continue;
detectCount++;
Vec4i bb(od.rect.x + 1, od.rect.y + 1, od.rect.x + od.rect.width, od.rect.y + od.rect.height);
// score matchScore for the ROC curve
double maxMatchScore = 0;
int maxMatchId = -1;
for (int k = 0; k < gtNumCrnt; k++) {
double matchScore = DataSetVOC::interUnio(bb, boxesGT[k]);
if (matchScore > maxMatchScore) {
maxMatchScore = matchScore;
maxMatchId = k;
}
}
uchar match = maxMatchScore > 0.5 ? 1 : 0;
if (match) {
int preDetectedIdx = gtIdx[maxMatchId];
if (preDetectedIdx >= 0) {
if (maxMatchScore > di[preDetectedIdx].matchScore) {
di[preDetectedIdx].matched = false;
gtIdx[maxMatchId] = int(j);
di[j].matchScore = maxMatchScore;
di[j].matched = true;
}
} else {
gtIdx[maxMatchId] = int(j);
di[j].matchScore = maxMatchScore;
di[j].matched = true;
}
}
}
for (size_t j = 0; j < detectCount; j++) {
const QUniLsvmDetector::ObjectDetection& od = detections[j];
if (di[j].matched)
matchCount++;
pScores.push_back(ScoreTp(od.score, di[j].matched));
}
#ifdef SAVE_YML
vector<Vec4i> newBoxesGT;
for (size_t j = 0; j < gtIdx.size(); j++) {
if (gtIdx[j] < 0)
continue;
newBoxesGT.push_back(boxesGT[j]);
}
if (newBoxesGT.size() > 0) {
// name
// h, w
string name = _S(voc.testSet[i]);
writePersonYml(name, image.rows, image.cols, newBoxesGT);
}
#endif
}
printf("QdpmRocTest time = %f sec\n", tm.getTimeSec());
printf("GT %d, Matched %d/%d \n", personCount, matchCount, pScores.size());
// Calculate log-average miss rate
stable_sort(begin(pScores), end(pScores),
[](const ScoreTp &p1, const ScoreTp &p2) { return p1.first > p2.first; });
vector<float> fp(pScores.size());
for (size_t i = 0; i < fp.size(); i++)
fp[i] = !pScores[i].second;
vector<float> tp(pScores.size());
tp[0] = pScores[0].second;
for (size_t i = 1; i < tp.size(); i++)
tp[i] = tp[i - 1] + pScores[i].second;
for (size_t i = 0; i < tp.size(); i++)
tp[i] /= personCount;
for (size_t i = 1; i < fp.size(); i++)
fp[i] += fp[i - 1];
for (size_t i = 0; i < fp.size(); i++)
fp[i] /= imageCount;
FILE *matlabFile = fopen("drawLAMR.m", "w");
printVector(matlabFile, tp, "tp");
printVector(matlabFile, fp, "fp");
char *matlabContent = "tp = tp'; fp = fp';\n"
"addpath(genpath('d:/81_dataset/03_Caltech/piotr_toolbox/')); savepath;\n"
"xs1=[-inf; fp];\n"
"ys1=[0; tp];\n"
"ref=10.^(-2:.25:0);\n"
"lims=[3.1e-4 1e1 0. 1];\n"
"m=length(ref);\n"
"for i=1:m\n"
"\tj=find(xs1<=ref(i));\n"
"\tmiss(i)=ys1(j(end));\n"
"end\n"
"miss=exp(mean(log(max(1e-10,1-miss))));\n"
"show=figure();\n"
"plotRoc([fp tp],'logx',1,'logy',1,'xLbl','fppi',...\n"
"\t'lims',lims,'color','g','smooth',1,'fpTarget',ref);\n"
"title(sprintf('log-average miss rate = %.2f%%',miss*100));\n"
"savefig(['MORU' 'Roc'],show,'png');\n";
fwrite(matlabContent, strlen(matlabContent), 1, matlabFile);
fclose(matlabFile);
return 0;
}
void App::run(int argc, char **argv)
{
parseCmdArgs(argc, argv);
if (help_showed)
return;
if (getCudaEnabledDeviceCount() == 0)
throw runtime_error("No GPU found or the library is compiled without GPU support");
if (cascade_name.empty())
{
cout << "Using default cascade file...\n";
cascade_name = "data/face_detect/haarcascade_frontalface_alt.xml";
}
if (!cascade_gpu.load(cascade_name) || !cascade_cpu.load(cascade_name))
{
stringstream msg;
msg << "Could not load cascade classifier \"" << cascade_name << "\"";
throw runtime_error(msg.str());
}
if (sources.size() != 1)
{
cout << "Loading default frames source...\n";
sources.resize(1);
sources[0] = new VideoSource("data/face_detect/browser.flv");
}
Mat frame, frame_cpu, gray_cpu, resized_cpu, faces_downloaded, frameDisp;
vector<Rect> facesBuf_cpu;
GpuMat frame_gpu, gray_gpu, resized_gpu, facesBuf_gpu;
int detections_num;
while (!exited)
{
sources[0]->next(frame_cpu);
frame_gpu.upload(frame_cpu);
convertAndResize(frame_gpu, gray_gpu, resized_gpu, scaleFactor);
convertAndResize(frame_cpu, gray_cpu, resized_cpu, scaleFactor);
TickMeter tm;
tm.start();
if (useGPU)
{
cascade_gpu.visualizeInPlace = true;
cascade_gpu.findLargestObject = findLargestObject;
detections_num = cascade_gpu.detectMultiScale(resized_gpu, facesBuf_gpu, 1.2,
(filterRects || findLargestObject) ? 4 : 0);
facesBuf_gpu.colRange(0, detections_num).download(faces_downloaded);
}
else
{
Size minSize = cascade_gpu.getClassifierSize();
cascade_cpu.detectMultiScale(resized_cpu, facesBuf_cpu, 1.2,
(filterRects || findLargestObject) ? 4 : 0,
(findLargestObject ? CV_HAAR_FIND_BIGGEST_OBJECT : 0)
| CV_HAAR_SCALE_IMAGE,
minSize);
detections_num = (int)facesBuf_cpu.size();
}
if (!useGPU && detections_num)
{
for (int i = 0; i < detections_num; ++i)
{
rectangle(resized_cpu, facesBuf_cpu[i], Scalar(255));
}
}
if (useGPU)
{
resized_gpu.download(resized_cpu);
}
tm.stop();
double detectionTime = tm.getTimeMilli();
double fps = 1000 / detectionTime;
/*//print detections to console
cout << setfill(' ') << setprecision(2);
cout << setw(6) << fixed << fps << " FPS, " << detections_num << " det";
if ((filterRects || findLargestObject) && detections_num > 0)
{
Rect *faceRects = useGPU ? faces_downloaded.ptr<Rect>() : &facesBuf_cpu[0];
for (int i = 0; i < min(detections_num, 2); ++i)
{
cout << ", [" << setw(4) << faceRects[i].x
<< ", " << setw(4) << faceRects[i].y
<< ", " << setw(4) << faceRects[i].width
<< ", " << setw(4) << faceRects[i].height << "]";
}
}
cout << endl;*/
cvtColor(resized_cpu, frameDisp, CV_GRAY2BGR);
displayState(frameDisp, helpScreen, useGPU, findLargestObject, filterRects, fps);
imshow("face_detect_demo", frameDisp);
processKey(waitKey(3));
}
}
int main(int argc, char **argv)
{
CommandLineParser parser(argc, argv, keys);
if (parser.has("help"))
{
parser.printMessage();
return 0;
}
String modelFile = parser.get<String>("model");
String imageFile = parser.get<String>("image");
if (!parser.check())
{
parser.printErrors();
return 0;
}
String classNamesFile = parser.get<String>("c_names");
String resultFile = parser.get<String>("result");
//! [Read model and initialize network]
dnn::Net net = dnn::readNetFromTorch(modelFile);
//! [Prepare blob]
Mat img = imread(imageFile), input;
if (img.empty())
{
std::cerr << "Can't read image from the file: " << imageFile << std::endl;
exit(-1);
}
Size origSize = img.size();
Size inputImgSize = cv::Size(1024, 512);
if (inputImgSize != origSize)
resize(img, img, inputImgSize); //Resize image to input size
Mat inputBlob = blobFromImage(img, 1./255); //Convert Mat to image batch
//! [Prepare blob]
//! [Set input blob]
net.setInput(inputBlob, ""); //set the network input
//! [Set input blob]
TickMeter tm;
String oBlob = net.getLayerNames().back();
if (!parser.get<String>("o_blob").empty())
{
oBlob = parser.get<String>("o_blob");
}
//! [Make forward pass]
tm.start();
Mat result = net.forward(oBlob);
tm.stop();
if (!resultFile.empty()) {
CV_Assert(result.isContinuous());
ofstream fout(resultFile.c_str(), ios::out | ios::binary);
fout.write((char*)result.data, result.total() * sizeof(float));
fout.close();
}
std::cout << "Output blob: " << result.size[0] << " x " << result.size[1] << " x " << result.size[2] << " x " << result.size[3] << "\n";
std::cout << "Inference time, ms: " << tm.getTimeMilli() << std::endl;
if (parser.has("show"))
{
std::vector<String> classNames;
vector<cv::Vec3b> colors;
if(!classNamesFile.empty()) {
colors = readColors(classNamesFile, classNames);
}
Mat segm, legend;
colorizeSegmentation(result, segm, legend, classNames, colors);
Mat show;
addWeighted(img, 0.1, segm, 0.9, 0.0, show);
cv::resize(show, show, origSize, 0, 0, cv::INTER_NEAREST);
imshow("Result", show);
if(classNames.size())
imshow("Legend", legend);
waitKey();
}
return 0;
} //main
/** @function main */
int main(int argc, char** argv)
{
TickMeter tm;
string detectorType = defaultDetectorType;
string descriptorType = defaultDescriptorType;
string matcherType = defaultMatcherType;
string queryFileName = defaultQueryFileName;
string trainFileName = defaultTrainFileName;
if(argc != 1 && argc != 4 && argc != 6)
{
readme(argv[0]);
return -1;
}
std::cout << argc << std::endl;
if(argc != 1)
{
detectorType = argv[1];
descriptorType = argv[2];
matcherType = argv[3];
if(argc != 4)
{
queryFileName = argv[4];
trainFileName = argv[5];
}
}
Mat trainImage = imread(trainFileName, CV_LOAD_IMAGE_GRAYSCALE);
Mat queryImage = imread(queryFileName, CV_LOAD_IMAGE_GRAYSCALE);
if(!trainImage.data || !queryImage.data)
{
std::cout << " --(!) Error reading images " << std::endl;
return -1;
}
//Create Detector Phase
Ptr<FeatureDetector> featureDetector;
Ptr<DescriptorExtractor> descriptorExtractor;
Ptr<DescriptorMatcher> descriptorMatcher;
initModule_nonfree();
if(!createDetectorDescriptorMatcher(detectorType, descriptorType, matcherType, featureDetector, descriptorExtractor, descriptorMatcher))
{
readme(argv[0]);
return -1;
}
//get keypoints phase
vector<KeyPoint> queryKeypoints;
vector<KeyPoint> trainKeypoints;
tm.start();
detectKeypoints(queryImage, queryKeypoints, featureDetector);
detectKeypoints(trainImage, trainKeypoints, featureDetector);
tm.stop();
double keypointTime = tm.getTimeMilli();
//get descriptor phase
Mat queryDescriptors;
Mat trainDescriptors;
tm.start();
computeDescriptors(queryImage, queryKeypoints, queryDescriptors, descriptorExtractor);
//computeDescriptors(trainImage, trainKeypoints, trainDescriptors, descriptorExtractor);
cv::FileStorage fs2("data.xml", cv::FileStorage::READ);
fs2["trainDescriptors"] >> trainDescriptors;
fs2.release();
tm.stop();
double descriptorTime = tm.getTimeMilli();
//matching Phase
vector<DMatch> matches;
tm.start();
matchDescriptors(trainDescriptors, queryDescriptors, matches, descriptorMatcher);
tm.stop();
double matcherTime = tm.getTimeMilli();
//show result Phase
double max_dist = 0; double min_dist = 100;
for( int i = 0; i < trainDescriptors.rows; i++ )
{
double dist = matches[i].distance;
if( dist < min_dist ) min_dist = dist;
if( dist > max_dist ) max_dist = dist;
}
vector<DMatch> good_matches;
for( int i = 0; i < trainDescriptors.rows; i++ )
{
if( matches[i].distance < 3*min_dist )
{
good_matches.push_back( matches[i]);
}
}
Mat matchesImage = showResultImages(trainImage, trainKeypoints, queryImage, queryKeypoints, matches);
Mat goodmatchesImage = showResultImages(trainImage, trainKeypoints, queryImage, queryKeypoints, good_matches);
namedWindow("matches", 1);
namedWindow("good_matches", 1);
imshow("matches", matchesImage);
imshow("good_matches", goodmatchesImage);
std::cout << "\n" << detectorType << " + " << descriptorType << " + " << matcherType << std::endl;
std::cout << "detecting time : " << keypointTime << " ms" << std::endl;
std::cout << "computing descriptor time : " << descriptorTime << " ms" << std::endl;
std::cout << "matching time : " << matcherTime << " ms" << std::endl;
std::cout << "total time : " << keypointTime + descriptorTime + matcherTime << " ms" << std::endl;
cv::FileStorage fs1("data.xml", cv::FileStorage::WRITE);
fs1 << "trainDescriptors" << trainDescriptors;
fs1.release();
cvWaitKey(0);
return 0;
}
int main(int argc, char** argv)
{
if (argc != 3)
{
cerr << "Usage: stereo_multi_gpu <left_video> <right_video>" << endl;
return -1;
}
const int numDevices = getCudaEnabledDeviceCount();
if (numDevices != 2)
{
cerr << "Two GPUs are required" << endl;
return -1;
}
for (int i = 0; i < numDevices; ++i)
{
DeviceInfo devInfo(i);
if (!devInfo.isCompatible())
{
cerr << "CUDA module was't built for GPU #" << i << " ("
<< devInfo.name() << ", CC " << devInfo.majorVersion()
<< devInfo.minorVersion() << endl;
return -1;
}
printShortCudaDeviceInfo(i);
}
VideoCapture leftVideo(argv[1]);
VideoCapture rightVideo(argv[2]);
if (!leftVideo.isOpened())
{
cerr << "Can't open " << argv[1] << " video file" << endl;
return -1;
}
if (!rightVideo.isOpened())
{
cerr << "Can't open " << argv[2] << " video file" << endl;
return -1;
}
cout << endl;
cout << "This sample demonstrates working on one piece of data using two GPUs." << endl;
cout << "It splits input into two parts and processes them separately on different GPUs." << endl;
cout << endl;
Mat leftFrame, rightFrame;
CudaMem leftGrayFrame, rightGrayFrame;
StereoSingleGpu gpu0Alg(0);
StereoSingleGpu gpu1Alg(1);
StereoMultiGpuThread multiThreadAlg;
StereoMultiGpuStream multiStreamAlg;
Mat disparityGpu0;
Mat disparityGpu1;
Mat disparityMultiThread;
CudaMem disparityMultiStream;
Mat disparityGpu0Show;
Mat disparityGpu1Show;
Mat disparityMultiThreadShow;
Mat disparityMultiStreamShow;
TickMeter tm;
cout << "-------------------------------------------------------------------" << endl;
cout << "| Frame | GPU 0 ms | GPU 1 ms | Multi Thread ms | Multi Stream ms |" << endl;
cout << "-------------------------------------------------------------------" << endl;
for (int i = 0;; ++i)
{
leftVideo >> leftFrame;
rightVideo >> rightFrame;
if (leftFrame.empty() || rightFrame.empty())
break;
if (leftFrame.size() != rightFrame.size())
{
cerr << "Frames have different sizes" << endl;
return -1;
}
leftGrayFrame.create(leftFrame.size(), CV_8UC1);
rightGrayFrame.create(leftFrame.size(), CV_8UC1);
cvtColor(leftFrame, leftGrayFrame.createMatHeader(), COLOR_BGR2GRAY);
cvtColor(rightFrame, rightGrayFrame.createMatHeader(), COLOR_BGR2GRAY);
tm.reset(); tm.start();
gpu0Alg.compute(leftGrayFrame.createMatHeader(), rightGrayFrame.createMatHeader(),
disparityGpu0);
tm.stop();
const double gpu0Time = tm.getTimeMilli();
tm.reset(); tm.start();
gpu1Alg.compute(leftGrayFrame.createMatHeader(), rightGrayFrame.createMatHeader(),
disparityGpu1);
tm.stop();
const double gpu1Time = tm.getTimeMilli();
tm.reset(); tm.start();
multiThreadAlg.compute(leftGrayFrame.createMatHeader(), rightGrayFrame.createMatHeader(),
disparityMultiThread);
tm.stop();
const double multiThreadTime = tm.getTimeMilli();
tm.reset(); tm.start();
multiStreamAlg.compute(leftGrayFrame, rightGrayFrame, disparityMultiStream);
tm.stop();
const double multiStreamTime = tm.getTimeMilli();
cout << "| " << setw(5) << i << " | "
<< setw(8) << setprecision(1) << fixed << gpu0Time << " | "
<< setw(8) << setprecision(1) << fixed << gpu1Time << " | "
<< setw(15) << setprecision(1) << fixed << multiThreadTime << " | "
<< setw(15) << setprecision(1) << fixed << multiStreamTime << " |" << endl;
resize(disparityGpu0, disparityGpu0Show, Size(1024, 768), 0, 0, INTER_AREA);
resize(disparityGpu1, disparityGpu1Show, Size(1024, 768), 0, 0, INTER_AREA);
resize(disparityMultiThread, disparityMultiThreadShow, Size(1024, 768), 0, 0, INTER_AREA);
resize(disparityMultiStream.createMatHeader(), disparityMultiStreamShow, Size(1024, 768), 0, 0, INTER_AREA);
imshow("disparityGpu0", disparityGpu0Show);
imshow("disparityGpu1", disparityGpu1Show);
imshow("disparityMultiThread", disparityMultiThreadShow);
imshow("disparityMultiStream", disparityMultiStreamShow);
const int key = waitKey(30) & 0xff;
if (key == 27)
break;
}
cout << "-------------------------------------------------------------------" << endl;
return 0;
}
void ObjectRecognition::matchObsvToDB(const Mat &img, string& ObjName)
{
//img.assignTo(img, CV_8U);
vector<DMatch> matches;
vector<vector<DMatch> > total_matches;
TickMeter tm;
tm.start();
vector<KeyPoint> imgKp;
Mat imgDesc;
detectKeypointsSingle(img, imgKp);
computeDescriptorsSingle(img, imgKp, imgDesc);
matcher->match( imgDesc, matches );
/*/
//Match each item in database to pic (problem is it then matches to best keypoint and need to find a way to see which image in database is best)
// I tried variance of distances but that wasn't reliable, didn't try finding var of angle but probably wouldn't be reliable either
for ( vector<DBobj>::iterator DBiter = DB.begin() ; DBiter != DB.end(); DBiter++ )
{
matcher->match( imgDesc, DBiter->description, matches);
total_matches.push_back(matches);
float mean = 0, var = 0;
for (vector<DMatch>::iterator DMiter = matches.begin(); DMiter != matches.end(); DMiter++) mean += DMiter->distance;
mean = mean / matches.size();
for (vector<DMatch>::iterator DMiter = matches.begin(); DMiter != matches.end(); DMiter++) var += (DMiter->distance - mean) * (DMiter->distance - mean);
cout << "# of Observed Matches to " << DBiter->name << " is " << matches.size() << " with a sd of: " << var << endl;
} /*/
tm.stop();
double matchTime = tm.getTimeMilli();
//for finding which picture has most matches
int numMatchesToDB [(int)DB.size()], bestMatchIdx=0;
//init array
for (int i = 0; i < (int)DB.size(); i++) numMatchesToDB[i] = 0;
//bin for finding which pic has most matches
for (vector<DMatch>::iterator DMiter = matches.begin(); DMiter != matches.end(); DMiter++)
{
numMatchesToDB[DMiter->imgIdx]++;
if ( numMatchesToDB[bestMatchIdx] < numMatchesToDB[DMiter->imgIdx] ) bestMatchIdx = DMiter->imgIdx;
//cout << "bestMatchIdx: " << numMatchesToDB[bestMatchIdx] << "\t" << numMatchesToDB[DMiter->imgIdx] << "\t" << bestMatchIdx << "\t" << DMiter->imgIdx << endl;
//cout << "Match information (queryIDx/trainIDx/imgIDx/distance): " <<
// DMiter->queryIdx << "\t" << DMiter->trainIdx << "\t" << DMiter->imgIdx << "\t" << DMiter->distance << endl;
}
cout << "Match time: " << matchTime << " ms with the best match at " << DB.at(bestMatchIdx).name << " with " << numMatchesToDB[bestMatchIdx] << " matching keypoints" << endl;
//cout << "Observed Descriptors " << imgDesc.rows << " and number of matches " << (int)matches.size() << endl;
CV_Assert( imgDesc.rows == (int)matches.size() || matches.empty() );
ObjName = DB.at(bestMatchIdx).name;
//*/ Show only bestMatchIdx pic
//preparing mask so not all keypoints are shown, only links where imgIdx (DB image position)
vector<char> mask;
mask.resize( matches.size() );
fill( mask.begin(), mask.end(), 0 );
for( size_t i = 0; i < matches.size(); i++ )
{
if( matches[i].imgIdx == bestMatchIdx )
mask[i] = 1;
}
Mat drawImg;
drawMatches( img, imgKp, DB.at(bestMatchIdx).img, DB.at(bestMatchIdx).keypoints, matches, drawImg, Scalar(255, 0, 0), Scalar(0, 255, 255), mask );
imshow(DB.at(bestMatchIdx).name, drawImg);
waitKey();
//*/
/*/ Show each match by pic
bool running = true;
Mat drawImg;
vector<char> mask;
vector<DBobj>::iterator DBiter = DB.begin();
for( size_t i = 0; running ; )
{
maskMatchesByTrainImgIdx( matches, (int)i, mask );
drawMatches( img, imgKp, DBiter->img, DBiter->keypoints, matches, drawImg, Scalar(255, 0, 0), Scalar(0, 255, 255), mask );
imshow("Matchs", drawImg);
switch ( (char) waitKey(5))
{
case 'q': case 'Q':
running = false;
break;
case 'i': case 'I':
//cout << (bool) DBiter != DB.end() << endl;
if (( DBiter != DB.end() ) && ( i < DB.size()-1 ))
{
DBiter++;
i++;
}
else
{
DBiter = DB.begin();
i = 0;
}
cout << DBiter->name << "\tNumber of Matches: " << numMatchesToDB[i] << endl;
break;
}
}
//*/
}
int main(int argc, const char *argv[])
{
if (argc == 1)
{
help();
return -1;
}
if (getCudaEnabledDeviceCount() == 0)
{
return cerr << "No GPU found or the library is compiled without GPU support" << endl, -1;
}
cv::gpu::printShortCudaDeviceInfo(cv::gpu::getDevice());
string cascadeName;
string inputName;
bool isInputImage = false;
bool isInputVideo = false;
bool isInputCamera = false;
for (int i = 1; i < argc; ++i)
{
if (string(argv[i]) == "--cascade")
cascadeName = argv[++i];
else if (string(argv[i]) == "--video")
{
inputName = argv[++i];
isInputVideo = true;
}
else if (string(argv[i]) == "--camera")
{
inputName = argv[++i];
isInputCamera = true;
}
else if (string(argv[i]) == "--help")
{
help();
return -1;
}
else if (!isInputImage)
{
inputName = argv[i];
isInputImage = true;
}
else
{
cout << "Unknown key: " << argv[i] << endl;
return -1;
}
}
CascadeClassifier_GPU cascade_gpu;
if (!cascade_gpu.load(cascadeName))
{
return cerr << "ERROR: Could not load cascade classifier \"" << cascadeName << "\"" << endl, help(), -1;
}
CascadeClassifier cascade_cpu;
if (!cascade_cpu.load(cascadeName))
{
return cerr << "ERROR: Could not load cascade classifier \"" << cascadeName << "\"" << endl, help(), -1;
}
VideoCapture capture;
Mat image;
if (isInputImage)
{
image = imread(inputName);
CV_Assert(!image.empty());
}
else if (isInputVideo)
{
capture.open(inputName);
CV_Assert(capture.isOpened());
}
else
{
capture.open(atoi(inputName.c_str()));
CV_Assert(capture.isOpened());
}
namedWindow("result", 1);
Mat frame, frame_cpu, gray_cpu, resized_cpu, faces_downloaded, frameDisp;
vector<Rect> facesBuf_cpu;
GpuMat frame_gpu, gray_gpu, resized_gpu, facesBuf_gpu;
/* parameters */
bool useGPU = true;
double scaleFactor = 1.0;
bool findLargestObject = false;
bool filterRects = true;
bool helpScreen = false;
int detections_num;
for (;;)
{
if (isInputCamera || isInputVideo)
{
capture >> frame;
if (frame.empty())
{
break;
}
}
(image.empty() ? frame : image).copyTo(frame_cpu);
frame_gpu.upload(image.empty() ? frame : image);
convertAndResize(frame_gpu, gray_gpu, resized_gpu, scaleFactor);
convertAndResize(frame_cpu, gray_cpu, resized_cpu, scaleFactor);
TickMeter tm;
tm.start();
if (useGPU)
{
cascade_gpu.visualizeInPlace = true;
cascade_gpu.findLargestObject = findLargestObject;
detections_num = cascade_gpu.detectMultiScale(resized_gpu, facesBuf_gpu, 1.2,
(filterRects || findLargestObject) ? 4 : 0);
facesBuf_gpu.colRange(0, detections_num).download(faces_downloaded);
}
else
{
Size minSize = cascade_gpu.getClassifierSize();
cascade_cpu.detectMultiScale(resized_cpu, facesBuf_cpu, 1.2,
(filterRects || findLargestObject) ? 4 : 0,
(findLargestObject ? CV_HAAR_FIND_BIGGEST_OBJECT : 0)
| CV_HAAR_SCALE_IMAGE,
minSize);
detections_num = (int)facesBuf_cpu.size();
}
if (!useGPU && detections_num)
{
for (int i = 0; i < detections_num; ++i)
{
rectangle(resized_cpu, facesBuf_cpu[i], Scalar(255));
}
}
if (useGPU)
{
resized_gpu.download(resized_cpu);
}
tm.stop();
double detectionTime = tm.getTimeMilli();
double fps = 1000 / detectionTime;
//print detections to console
cout << setfill(' ') << setprecision(2);
cout << setw(6) << fixed << fps << " FPS, " << detections_num << " det";
if ((filterRects || findLargestObject) && detections_num > 0)
{
Rect *faceRects = useGPU ? faces_downloaded.ptr<Rect>() : &facesBuf_cpu[0];
for (int i = 0; i < min(detections_num, 2); ++i)
{
cout << ", [" << setw(4) << faceRects[i].x
<< ", " << setw(4) << faceRects[i].y
<< ", " << setw(4) << faceRects[i].width
<< ", " << setw(4) << faceRects[i].height << "]";
}
}
cout << endl;
cvtColor(resized_cpu, frameDisp, CV_GRAY2BGR);
displayState(frameDisp, helpScreen, useGPU, findLargestObject, filterRects, fps);
imshow("result", frameDisp);
char key = (char)waitKey(5);
if (key == 27)
{
break;
}
switch (key)
{
case ' ':
useGPU = !useGPU;
break;
case 'm':
case 'M':
findLargestObject = !findLargestObject;
break;
case 'f':
case 'F':
filterRects = !filterRects;
break;
case '1':
scaleFactor *= 1.05;
break;
case 'q':
case 'Q':
scaleFactor /= 1.05;
break;
case 'h':
case 'H':
helpScreen = !helpScreen;
break;
}
}
int main(int argc, char *argv[])
{
srand(42);
RNG &rng = theRNG();
rng.state = 0xffffffff;
if (argc != 4)
{
cout << argv[0] << " <baseFolder> <modelsPath> <testObjectName>" << endl;
return -1;
}
string baseFolder = argv[1];
string trainedModelsPath = argv[2];
string testObjectName = argv[3];
const string testFolder = baseFolder + "/" + testObjectName + "/";
const string imageFilename = baseFolder + "/image.png";
const string depthFilename = baseFolder + "/depth.xml.gz";
const string pointCloudFilename = baseFolder + "/pointCloud.pcd";
const vector<string> objectNames(1, testObjectName);
// const vector<string> objectNames = {"bank", "bottle", "glass", "sourCream", "wineglass"};
// const vector<string> objectNames = {"bank", "bottle", "sourCream", "wineglass"};
// const vector<string> objectNames = {"bank", "bottle", "wineglass"};
// const vector<string> objectNames = {"bank", "wineglass"};
// const vector<string> objectNames = {"wineglass"};
//, "bottle", "glass", "sourCream", "wineglass"};
DetectorParams params;
// params.glassSegmentationParams.closingIterations = 12;
// params.glassSegmentationParams.openingIterations = 8;
// params.glassSegmentationParams.finalClosingIterations = 8;
// params.glassSegmentationParams.finalClosingIterations = 12;
//good clutter
/*
params.glassSegmentationParams.openingIterations = 15;
params.glassSegmentationParams.closingIterations = 12;
params.glassSegmentationParams.finalClosingIterations = 32;
params.glassSegmentationParams.grabCutErosionsIterations = 4;
params.planeSegmentationMethod = FIDUCIALS;
*/
//test_planar_glass
params.planeSegmentationMethod = RGBD;
params.glassSegmentationParams.grabCutErosionsIterations = 3;
params.glassSegmentationParams.grabCutDilationsIterations = 3;
TODBaseImporter dataImporter(baseFolder, testFolder);
Mat kinectDepth, kinectBgrImage;
dataImporter.importBGRImage(imageFilename, kinectBgrImage);
dataImporter.importDepth(depthFilename, kinectDepth);
imshow("rgb image", kinectBgrImage);
imshow("depth", kinectDepth);
waitKey(500);
Mat registrationMask;
PinholeCamera kinectCamera;
vector<EdgeModel> edgeModels;
dataImporter.importAllData(&trainedModelsPath, &objectNames, &kinectCamera, ®istrationMask, &edgeModels);
Detector detector(kinectCamera, params);
for (size_t i = 0; i < edgeModels.size(); ++i)
{
detector.addTrainObject(objectNames[i], edgeModels[i]);
}
vector<Point3f> testPointCloud;
//dataImporter.importPointCloud(pointCloudFilename, testPointCloud);
#ifdef SHOW_CLOUD
Mat points3d;
depthTo3d(kinectDepth, kinectCamera.cameraMatrix, points3d);
testPointCloud = points3d.reshape(3, points3d.total());
#endif
vector<PoseRT> poses_cam;
vector<float> posesQualities;
vector<string> detectedObjectsNames;
TickMeter recognitionTime;
recognitionTime.start();
Detector::DebugInfo debugInfo;
try
{
detector.detect(kinectBgrImage, kinectDepth, registrationMask, testPointCloud, poses_cam, posesQualities, detectedObjectsNames, &debugInfo);
}
catch(const cv::Exception &)
{
}
#ifdef USE_INITIAL_GUESS
{
PoseRT initialPose;
//3
initialPose.rvec = (Mat_<double>(3, 1) << -0.8356714356174999, 0.08672943393358865, 0.1875608929524414);
initialPose.tvec = (Mat_<double>(3, 1) << -0.0308572565967134, 0.1872369696442459, 0.8105566363422957);
poses_cam.push_back(initialPose);
//TODO: move up
posesQualities.push_back(1.0f);
GlassSegmentator glassSegmentator(params.glassSegmentationParams);
Mat glassMask;
int numberOfComponents;
glassSegmentator.segment(kinectBgrImage, kinectDepth, registrationMask, numberOfComponents, glassMask);
showSegmentation(kinectBgrImage, glassMask);
transpod::PoseEstimator poseEstimator(kinectCamera);
poseEstimator.setModel(edgeModels[0]);
Vec4f tablePlane;
computeTableOrientationByFiducials(kinectCamera, kinectBgrImage, tablePlane);
poseEstimator.refinePosesBySupportPlane(kinectBgrImage, glassMask, tablePlane, poses_cam, posesQualities);
Mat finalVisualization = kinectBgrImage.clone();
poseEstimator.visualize(poses_cam[0], finalVisualization);
imshow("estimated poses", finalVisualization);
waitKey();
}
#endif
recognitionTime.stop();
cout << "Recognition time: " << recognitionTime.getTimeSec() << "s" << endl;
Mat glassMask = debugInfo.glassMask;
imshow("glassMask", glassMask);
showSegmentation(kinectBgrImage, glassMask, "segmentation");
/*
Mat detectionResults = kinectBgrImage.clone();
detector.visualize(poses_cam, detectedObjectsNames, detectionResults);
imshow("detection", detectionResults);
waitKey();
*/
cout << "number of detected poses: " << poses_cam.size() << endl;
cout << "number of qualities: " << posesQualities.size() << endl;
if (!posesQualities.empty())
{
cout << "quality: " << posesQualities[0] << endl;
std::vector<float>::iterator bestDetection = std::min_element(posesQualities.begin(), posesQualities.end());
int bestDetectionIndex = std::distance(posesQualities.begin(), bestDetection);
cout << "Recognized object: " << detectedObjectsNames[bestDetectionIndex] << endl;
Mat detectionResults = kinectBgrImage.clone();
// vector<PoseRT> bestPose(1, poses_cam[bestDetectionIndex]);
vector<string> bestName(1, detectedObjectsNames[bestDetectionIndex]);
// detector.visualize(bestPose, bestName, detectionResults);
detector.visualize(poses_cam, detectedObjectsNames, detectionResults);
imshow("detection", detectionResults);
imwrite("detection_" + bestName[0] + ".png", detectionResults);
imwrite("testImage_" + bestName[0] + ".png", kinectBgrImage);
}
waitKey();
#ifdef SHOW_CLOUD
detector.visualize(poses_cam, detectedObjectsNames, testPointCloud);
#endif
return 0;
}
