void StabilizeStepper::initialize_neighbor_list_managers() { const std::size_t num_beads(_space->num_beads()); PairList bond_pair(num_beads); std::list<std::pair<std::size_t, std::size_t> > bonds(_model->list_bonds()); for (auto itr(bonds.begin()); itr != bonds.end(); itr++) { bond_pair.add_pair(*itr); bond_pair.add_pair(std::make_pair((*itr).second, (*itr).first)); } PairList excludes(num_beads); for (std::size_t i(0); i < num_beads; ++i) { for (auto itr(bond_pair.begin(i)); itr != bond_pair.end(i); ++itr) { excludes.add_pair(std::make_pair(i, *itr)); for (auto jtr(bond_pair.begin(*itr)); jtr != bond_pair.end(*itr); ++jtr) { excludes.add_pair(std::make_pair(i, *jtr)); } } } Model::inter_potential_container inter_potentials(_model->list_inter_potentials()); for (auto itr(inter_potentials.begin()); itr != inter_potentials.end(); ++itr) { const double r_c((*itr)->get_cutoff_radius()); NeighborListManager manager(num_beads, r_c, r_c*3, std::numeric_limits<double>::infinity()); // TODO parameter fitting (*itr)->set_neighbor_list(manager.get_neighbor_list()); for (std::size_t i(0); i < num_beads-1; ++i) { std::string symbol0(_space->symbol(i)); for (std::size_t j(i+1); j < num_beads; j++) { std::string symbol1(_space->symbol(j)); if ((*itr)->is_valid_pair(symbol0, symbol1)) { bool is_exclude(false); for (auto itr2(excludes.begin(i)); itr2 != excludes.end(i); ++itr2) if (j == *itr2) { is_exclude = true; break; } if (!is_exclude) manager.add_candidate(std::make_pair(i,j)); } } } manager.update(*(_space.get())); _neighbor_list_managers.push_back(manager); } }
forceinline ExecStatus Sequence<View,Val>::check(Space& home, ViewArray<View>& x, Val s, int q, int l, int u) { Region r(home); // could do this with an array of length q... int* upper = r.alloc<int>(x.size()+1); int* lower = r.alloc<int>(x.size()+1); upper[0] = 0; lower[0] = 0; for ( int j=0; j<x.size(); j++ ) { upper[j+1] = upper[j]; lower[j+1] = lower[j]; if (includes(x[j],s)) { upper[j+1] += 1; } else if (excludes(x[j],s)) { lower[j+1] += 1; } if ( j+1 >= q && (q - l < lower[j+1] - lower[j+1-q] || upper[j+1] - upper[j+1-q] > u) ) { return ES_FAILED; } } return ES_OK; }
int main(int argc, char *argv[]) { std::string train_path; std::string gt_path; std::string output_file; std::string output_patch_file; int numbers = 0; int start = 100; int c; std::vector<int> excludes(nexcludes); excludes.assign(exclude_nums, exclude_nums + nexcludes); while ((c = getopt(argc, argv, "i:g:n:s:e:o:p:h")) != -1) { switch (c) { case 'i': train_path = optarg; break; case 'g': gt_path = optarg; break; case 'n': { std::stringstream stream(optarg); stream >> numbers; } break; case 's': { std::stringstream stream(optarg); stream >> start; } break; case 'e': excludes = spliti(std::string(optarg),','); break; case 'o': output_file = optarg; break; case 'p': output_patch_file = optarg; break; case 'h': default: std::cout << c << std::endl; std::cerr << "Usage: extract_train_set OPTIONS" << std::endl << "\t -i <training directory>" << std::endl << "\t -g <gt box directory>" << std::endl << "\t -n <maximum id>" << std::endl << "\t -s <start id>" << std::endl << "\t -o <output path>" << std::endl << "\t -p <output patch file>" << std::endl << "\t -e <exclude list>" << std::endl; return 1; } } if (train_path == "" || gt_path == "") { std::cerr << "Training path and gt path are mandatory" << std::endl; return 1; } if (output_file == "") { std::cerr << "output file is mandatory" << std::endl; return 1; } srand(time(NULL)); std::ofstream ofs(output_file.c_str()); std::ofstream ofs_patch; if (output_patch_file != "") { ofs_patch.open(output_patch_file); } for (unsigned int i = start; i <= numbers; ++i) { if (std::find(excludes.begin(), excludes.end(), i) != excludes.end()) continue; std::cout << "Processing: " << i << std::endl; std::string train_img; std::string gt_box; { std::stringstream stream(train_path); stream << train_path << "/" << i << ".jpg"; train_img = (stream.str()); } { std::stringstream stream(gt_path); stream << gt_path << "/" << i << ".txt"; gt_box = (stream.str()); } std::vector<cv::Rect> rects(read_boxes(gt_box)); cv::Mat img = cv::imread(train_img); // first we extract the positive instances for (unsigned int j = 0; j < rects.size(); ++j) { extract_positive_samples(img, rects[j], ofs, ofs_patch); } std::cout << "Extracting random images" << std::endl; // then we gonna extract negative samples float size = img.rows; cv::Mat scaledImage = img; float scale = 1.0; for (unsigned int j = 0; j < nscales; ++j) { std::cout << "scale: " << size << std::endl; if (scaledImage.rows > (int) size) { float ratio = size / scaledImage.rows; int h = (int) size; int w = ratio * scaledImage.cols; std::cout << w << " " << h << " " << ratio << std::endl; cv::resize(img, scaledImage, cv::Size(w,h)); rects = scale_rects(rects, ratio); scale = scale * ratio; } if (scaledImage.rows < window_height || scaledImage.cols < window_width) { continue; } extract_negative_samples(scaledImage, rects, scale, ofs, ofs_patch); size = size * scale_ratio; } } return 0; }
TrafficPattern * TrafficPattern::New(string const & pattern, int nodes) { string pattern_name; string param_str; size_t left = pattern.find_first_of('('); if(left == string::npos) { pattern_name = pattern; } else { pattern_name = pattern.substr(0, left); size_t right = pattern.find_last_of(')'); if(right == string::npos) { param_str = pattern.substr(left+1); } else { param_str = pattern.substr(left+1, right-left-1); } } vector<string> params = tokenize(param_str); TrafficPattern * result = NULL; if(pattern_name == "bitcomp") { result = new BitCompTrafficPattern(nodes); } else if(pattern_name == "transpose") { result = new TransposeTrafficPattern(nodes); } else if(pattern_name == "bitrev") { result = new BitRevTrafficPattern(nodes); } else if(pattern_name == "shuffle") { result = new ShuffleTrafficPattern(nodes); } else if(pattern_name == "randperm") { int perm_seed = params.empty() ? 0 : atoi(params[0].c_str()); result = new RandomPermutationTrafficPattern(nodes, perm_seed); } else if(pattern_name == "uniform") { result = new UniformRandomTrafficPattern(nodes); } else if(pattern_name == "background") { vector<string> excludes_str = tokenize(params[0]); vector<int> excludes(excludes_str.size()); for(size_t i = 0; i < excludes.size(); ++i) { excludes[i] = atoi(excludes_str[i].c_str()); } result = new UniformBackgroundTrafficPattern(nodes, excludes); } else if(pattern_name == "diagonal") { result = new DiagonalTrafficPattern(nodes); } else if(pattern_name == "asymmetric") { result = new AsymmetricTrafficPattern(nodes); } else if(pattern_name == "taper64") { result = new Taper64TrafficPattern(nodes); } else if(pattern_name == "bad_dragon") { if(params.size() < 2) { cout << "Error: Missing parameters for dragonfly bad permutation traffic pattern: " << pattern << endl; exit(-1); } int k = atoi(params[0].c_str()); int n = atoi(params[1].c_str()); result = new BadPermDFlyTrafficPattern(nodes, k, n); } else if((pattern_name == "tornado") || (pattern_name == "neighbor") || (pattern_name == "badperm_yarc")) { if(params.size() < 3) { cout << "Error: Missing parameters for digit permutation traffic pattern: " << pattern << endl; exit(-1); } int k = atoi(params[0].c_str()); int n = atoi(params[1].c_str()); int xr = atoi(params[2].c_str()); if(pattern_name == "tornado") { result = new TornadoTrafficPattern(nodes, k, n, xr); } else if(pattern_name == "neighbor") { result = new NeighborTrafficPattern(nodes, k, n, xr); } else if(pattern_name == "badperm_yarc") { result = new BadPermYarcTrafficPattern(nodes, k, n, xr); } } else if(pattern_name == "hotspot") { if(params.empty()) { cout << "Error: Missing parameter for hotspot traffic pattern: " << pattern << endl; exit(-1); } vector<string> hotspots_str = tokenize(params[0]); vector<int> hotspots(hotspots_str.size()); for(size_t i = 0; i < hotspots.size(); ++i) { hotspots[i] = atoi(hotspots_str[i].c_str()); } vector<int> rates(hotspots.size(), 1); if(params.size() >= 2) { vector<string> rates_str = tokenize(params[1]); rates_str.resize(hotspots.size(), rates_str.back()); for(size_t i = 0; i < rates.size(); ++i) { rates[i] = atoi(rates_str[i].c_str()); } } result = new HotSpotTrafficPattern(nodes, hotspots, rates); } else { cout << "Error: Unknown traffic pattern: " << pattern << endl; exit(-1); } return result; }