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