int main(int argc, char** argv){ std::ofstream outputFile; /* Deals with optional argument (ie. output file) */ switch (argc){ case (4): output = &std::cout; cerr<<"No output file, using standard output."<<endl; break; case (5): outputFile.open(argv[4]); if(outputFile.fail()){ std::cerr<<"Error opening file : "<<argv[4]<<"."<<std::endl; exit(EXIT_FAILURE); } output = &outputFile; break; default : cout << "Usage = " << argv[0] << "<nor/gra/norwTSs> <input file name> <absolute support threshold> <output file>" << endl ; cout << "nor : Normal frequent definition" << endl; cout << "gra : GRAAK frequent definition" << endl; cout << "norwTSs : Normal frequent definition with computing transaction sequences" << endl; exit(EXIT_FAILURE); } cout<<"\n -----Debut du programm------ " << endl; // Recover arguments string freType = argv[1] ; char* inputFileName = argv[2] ; float threshold = atof(argv[3]) ; string so = "n";//argv[4] ; DBMain * dbmain = LoadBase(inputFileName); TimeTracker tt; tt.Start(); GLCM glcm = GLCM(); glcm.GLCMAlgo(dbmain,threshold,freType,so,*output); double ts = tt.Stop(); cout<<"------------FIN----------"<<endl; glcm.PrintNoClosed(); cout << "Total: " << setw(5) << ts << " sec" << endl; ostringstream ost; ost << getpid (); string cmd="ps -p "+ost.str ()+" -o rss"; cout << "Total Memory usage : " << endl; //system(cmd.c_str()); delete dbmain; return 0; }
double run() { Setup(lattice).setup(); Solver solver(lattice); TimeTracker tt; tt.start(); solver.run(); tt.stop(); return tt.elapsedSeconds(); }
// Very simple void greedy() { TimeTracker tt; tt.start(); // Could be optimized a LOT bool changed; do{ changed = false; for(node_ptr n = lattice.begin(); n != lattice.end(); ++n) { if(n->gain > 0) { flipNode<3>(n); changed = true; } } }while(changed); tt.stop(); cout << "Greedy finished in " << tt.asString() << "." << endl; }
template <int nd, typename Kernel> void run_benchmark(char mode, size_t edge_size, size_t random_seed) { typedef typename Indexer<nd>::index_vect index_vect; vector<dtype> X; ImageOptions opt; construct_random_bitmap<nd>(X, edge_size, opt, 10000 + random_seed); index_vect dimensions(edge_size); // Now run it... TimeTracker tt; tt.start(); _LatticeEnergy<nd, Kernel, dtype> le_qbp(dimensions); GraphCutEnergyWrapper<nd> le_gc(dimensions); make<nd>(&le_qbp, &le_gc, mode, opt, X, edge_size); tt.stop(); cout << "Time taken in setup = " << tt.asString() << "." << endl; cout << "Starting LatticeEnergy version." << endl; tt.reset(); tt.start(); le_qbp.run(); tt.stop(); cout << "Time taken in QBP optimization = " << tt.asString() << "." << endl; cout << "Starting GraphCuts version." << endl; tt.reset(); tt.start(); le_gc.run(); tt.stop(); cout << "Time taken in GC optimization = " << tt.asString() << "." << endl; size_t n_pos = 0; size_t n_neg = 0; size_t fpos_mismatch_count = 0; size_t fneg_mismatch_count = 0; for(IndexIterator<nd> idxit(dimensions); !idxit.done(); ++idxit) { bool q_on = le_qbp.on(idxit.coords()); bool gc_on = le_gc.on(idxit.coords()); if(!q_on && gc_on) ++fneg_mismatch_count; if(q_on && !gc_on) ++fpos_mismatch_count; ++(q_on ? n_pos : n_neg); } if( (fneg_mismatch_count + fpos_mismatch_count) != 0) { cout << "WARNING: mismatch count between QBP and GC is " << (fneg_mismatch_count + fpos_mismatch_count) << " (false negatives = " << fneg_mismatch_count << ", false positives = " << fpos_mismatch_count << ", total negatives = " << n_neg << ", total positives = " << n_pos << ")" << "!" << endl; } else { cout << "Solutions exactly match." << endl; } }
int main(int argc, char **argv) { ArgumentParser *argp = new ArgumentParser(argc, argv, "h:f:c:"); if (argp->has_arg("h") && argp->has_arg("f")) // read image from file { const char *cascade_file = argp->arg("h"); const char *image_file = argp->arg("f"); JpegReader * reader = new JpegReader(image_file); unsigned char *buffer = malloc_buffer(YUV422_PLANAR, reader->pixel_width(), reader->pixel_height()); reader->set_buffer(buffer); reader->read(); FacesClassifier *classifier = new FacesClassifier(cascade_file, reader->pixel_width(), reader->pixel_height()); classifier->set_src_buffer(buffer, reader->pixel_width(), reader->pixel_height()); std::list<ROI> *rois = classifier->classify(); FilterROIDraw *roi_draw = new FilterROIDraw(); for (std::list<ROI>::iterator i = rois->begin(); i != rois->end(); ++i) { printf("ROI: start (%u, %u) extent %u x %u\n", (*i).start.x, (*i).start.y, (*i).width, (*i).height); roi_draw->set_dst_buffer(buffer, &(*i)); roi_draw->apply(); } ImageDisplay *display = new ImageDisplay(reader->pixel_width(), reader->pixel_height()); display->show(buffer); display->loop_until_quit(); delete display; delete rois; free(buffer); delete reader; delete classifier; } else if (argp->has_arg("h") && argp->has_arg("c")) // get images from camera { const char *cascade_file = argp->arg("h"); Camera *camera = NULL; try { camera = CameraFactory::instance(argp->arg("c")); camera->open(); camera->start(); } catch (Exception &e) { printf("Failed to open camera.\n"); delete camera; return (-1); } printf("successfully opened camera: w=%d h=%d\n", camera->pixel_width(), camera->pixel_height()); TimeTracker *tt = new TimeTracker(); unsigned int ttc_recognition = tt->add_class("Face recognition"); unsigned int loop_count = 0; IplImage *image = cvCreateImage(cvSize(camera->pixel_width(), camera->pixel_height()), IPL_DEPTH_8U, 3); IplImage *scaled_image = cvCreateImage(cvSize(camera->pixel_width() / 2, camera->pixel_height() / 2), IPL_DEPTH_8U, 3); FacesClassifier *classifier = new FacesClassifier(cascade_file, camera->pixel_width(), camera->pixel_height(), scaled_image, 1.2 /* scale factor */, 2 /* min neighbours */, CV_HAAR_DO_CANNY_PRUNING); unsigned char *display_buffer = (unsigned char *)malloc(camera->buffer_size()); ImageDisplay *display = new ImageDisplay(camera->pixel_width(), camera->pixel_height(), "QA Faces Classifier"); Drawer *drawer = new Drawer(); drawer->set_buffer(display_buffer, camera->pixel_width(), camera->pixel_height()); SDL_Event redraw_event; redraw_event.type = SDL_KEYUP; redraw_event.key.keysym.sym = SDLK_SPACE; SDL_PushEvent(&redraw_event); bool quit = false; while (!quit) { SDL_Event event; if (SDL_WaitEvent(&event)) { switch (event.type) { case SDL_QUIT: quit = true; break; case SDL_KEYUP: if (event.key.keysym.sym == SDLK_SPACE) { camera->capture(); if (camera->buffer() != NULL) { IplImageAdapter::convert_image_bgr(camera->buffer(), image); cvResize(image, scaled_image, CV_INTER_LINEAR); memcpy(display_buffer, camera->buffer(), camera->buffer_size()); tt->ping_start(ttc_recognition); std::list<ROI> *rois = classifier->classify(); tt->ping_end(ttc_recognition); camera->dispose_buffer(); bool first = true; for (std::list<ROI>::reverse_iterator i = rois->rbegin(); i != rois->rend(); ++i) { if (first) { drawer->set_color(127, 70, 200); } drawer->draw_rectangle(2 * i->start.x, 2 * i->start.y, 2 * i->width, 2 * i->height); if (first) { drawer->set_color(30, 30, 30); first = false; } } if (++loop_count % 15 == 0) { tt->print_to_stdout(); } display->show(display_buffer); } SDL_PushEvent(&redraw_event); } else if (event.key.keysym.sym == SDLK_ESCAPE) { quit = true; } break; default: break; } } } camera->stop(); camera->close(); delete camera; delete display; delete drawer; free(display_buffer); cvReleaseImage(&image); cvReleaseImage(&scaled_image); delete tt; } else { printf("Usage: %s -h <Haar cascade file> -f <Image file as JPEG>\n", argv[0]); printf(" or %s -h <Haar cascade file> -c <Camera argument string>\n", argv[0]); exit(-1); } delete argp; }
int main(int argc, char **argv) { TimeTracker *tt = new TimeTracker(); unsigned int loop_count = 0; unsigned int ttc_trans = tt->add_class("Tra"); unsigned int ttc_rot = tt->add_class("Rot"); unsigned int ttc_inv = tt->add_class("Inv"); HomTransform ht; for (loop_count = 0; loop_count < 10; ++loop_count) { tt->ping_start(ttc_trans); ht.trans(1, 2, 3); tt->ping_end(ttc_trans); tt->ping_start(ttc_rot); ht.rotate_x(M_PI_2); tt->ping_end(ttc_rot); tt->ping_start(ttc_trans); ht.trans(1, 2, 3); tt->ping_end(ttc_trans); tt->ping_start(ttc_rot); ht.rotate_y(23); tt->ping_end(ttc_rot); tt->ping_start(ttc_trans); ht.trans(1, 2, 3); tt->ping_end(ttc_trans); tt->ping_start(ttc_rot); ht.rotate_z(M_PI_2); tt->ping_end(ttc_rot); tt->ping_start(ttc_inv); ht.invert(); tt->ping_end(ttc_inv); tt->ping_start(ttc_inv); ht.invert(); tt->ping_end(ttc_inv); } ht.print_info("HomTransform"); HomPoint p0 = HomPoint(0.1f, 0.2f, 0.3f); cout << "0: " << p0 << endl << endl << endl; HomPoint p = ht * p0; cout << "p: " << p << endl << endl << endl; ht.invert().print_info("HomTransform inverted"); p0 = ht * p; cout << "0': " << p0 << endl << endl << endl; ht.invert().print_info("HomTransform"); tt->print_to_stdout(); ht *= ht; delete tt; }
static void runESL(const ESLOptions& opt) { TimeTracker timer; timer.resume(); { // early test that we have permission to write to output file OutStream outs(opt.outputFilename); } typedef std::shared_ptr<bam_streamer> stream_ptr; std::vector<stream_ptr> bamStreams; // setup all data for main alignment loop: for (const std::string& afile : opt.alignFileOpt.alignmentFilename) { stream_ptr tmp(new bam_streamer(afile.c_str(), (opt.region.empty() ? NULL : opt.region.c_str()))); bamStreams.push_back(tmp); } const unsigned bamCount(bamStreams.size()); assert(0 != bamCount); // check bam header compatibility: if (bamCount > 1) { /// TODO: provide a better error exception for failed bam header check: const bam_header_t* compareHeader(bamStreams[0]->get_header()); for (unsigned bamIndex(1); bamIndex<bamCount; ++bamIndex) { const bam_header_t* indexHeader(bamStreams[bamIndex]->get_header()); if (! check_header_compatibility(compareHeader,indexHeader)) { log_os << "ERROR: incompatible bam headers between files:\n" << "\t" << opt.alignFileOpt.alignmentFilename[0] << "\n" << "\t" << opt.alignFileOpt.alignmentFilename[bamIndex] << "\n"; exit(EXIT_FAILURE); } } } // assume headers compatible after this point.... const bam_header_t& header(*(bamStreams[0]->get_header())); const bam_header_info bamHeader(header); int32_t tid(0), beginPos(0), endPos(0); parse_bam_region(bamHeader,opt.region,tid,beginPos,endPos); const GenomeInterval scanRegion(tid,beginPos,endPos); #ifdef DEBUG_ESL static const std::string log_tag("EstimateSVLoci"); log_os << log_tag << " scanRegion= " << scanRegion << "\n"; #endif // grab the reference for segment we're estimating plus a buffer around the segment edges: static const unsigned refEdgeBufferSize(500); reference_contig_segment refSegment; getIntervalReferenceSegment(opt.referenceFilename, bamHeader, refEdgeBufferSize, scanRegion, refSegment); SVLocusSetFinder locusFinder(opt, scanRegion, bamHeader, refSegment); input_stream_data sdata; for (unsigned bamIndex(0); bamIndex<bamCount; ++bamIndex) { sdata.register_reads(*bamStreams[bamIndex],bamIndex); } // loop through alignments: input_stream_handler sinput(sdata); while (sinput.next()) { const input_record_info current(sinput.get_current()); if (current.itype != INPUT_TYPE::READ) { log_os << "ERROR: invalid input condition.\n"; exit(EXIT_FAILURE); } const bam_streamer& readStream(*bamStreams[current.sample_no]); const bam_record& read(*(readStream.get_record_ptr())); locusFinder.update(read, current.sample_no); } // finished updating: locusFinder.flush(); timer.stop(); const CpuTimes totalTimes(timer.getTimes()); #ifdef DEBUG_ESL log_os << log_tag << " found " << locusFinder.getLocusSet().size() << " loci. \n"; log_os << log_tag << " totalTime: "; totalTimes.reportHr(log_os); log_os << "\n"; #endif locusFinder.setBuildTime(totalTimes); locusFinder.getLocusSet().save(opt.outputFilename.c_str()); }