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; }