static int cmd_decode(const char* path, const char** field_names, int names_length)
{
tdb* db = tdb_init(); assert(db);
tdb_error err = tdb_open(db, path);
if(err) {
REPORT_ERROR("Failed to open TDB. error=%i\n", err);
return 1;
}
tdb_field* ids;
err = resolve_fieldids(&ids, db, field_names, names_length);
if(err)
goto out;
/** actual field names (except for timestamp) */
for(int i = 0; i < names_length; ++i) {
assert(ids[i] > 0 && "reading from timestamp column 0 not supported");
--ids[i];
}
TIMED("cmd_decode", err, do_get_all_and_decode(db, path, ids, (unsigned)names_length));
out:
tdb_close(db);
return err;
}
void poll_networking(void)
{
uint64_t now;
if (!netif)
return;
/* poll interface */
netfrontif_poll(netif, LWIP_NETIF_MAX_RXBURST_LEN);
/* process lwIP timers */
now = NSEC_TO_MSEC(NOW());
TIMED(now, ts_etharp, ARP_TMR_INTERVAL, etharp_tmr());
TIMED(now, ts_ipreass, IP_TMR_INTERVAL, ip_reass_tmr());
TIMED(now, ts_tcp, TCP_TMR_INTERVAL, tcp_tmr());
TIMED(now, ts_dns, DNS_TMR_INTERVAL, dns_tmr());
}
static int cmd_append_all(const char* output_path, const char* input)
{
tdb* db = tdb_init(); assert(db);
int err = tdb_open(db, input);
if(err) {
REPORT_ERROR("Failed to open TDB. error=%i\n", err);
return 1;
}
const uint64_t num_fields = tdb_num_fields(db) - 1;
const char** field_ids = duplicate_fieldids(db);
tdb_cons* cons = tdb_cons_init();
assert(cons);
err = tdb_cons_open(cons, output_path, field_ids, num_fields);
if(err) {
REPORT_ERROR("Failed to create TDB cons. error=%i\n", err);
goto free_fieldids;
}
TIMED("tdb_cons_append()", err, tdb_cons_append(cons, db));
if(err) {
REPORT_ERROR("Failed to append DB. error=%i\n", err);
goto close_cons;
}
err = tdb_cons_finalize(cons);
if(err) {
REPORT_ERROR("Failed to finalize output DB. error=%i\n", err);
goto close_cons;
}
printf("Successfully converted / rewritten DB.\n");
close_cons:
tdb_cons_close(cons);
free_fieldids:
/* to make the compiler not complain about casting const'ness away,
let's pull out this small, dirty trick */
for(uint64_t i = 0; i < num_fields; ++i) {
void* make_compiler_happy;
memcpy(&make_compiler_happy, field_ids + i, sizeof(void*));
free(make_compiler_happy);
}
free(field_ids);
tdb_close(db);
return err ? 1 : 0;
}
/**
* copies a subset of data from one DB into another one. The subset is
* given by field names
*/
static int cmd_recode(const char* output_path, const char* input,
const char** field_names, int names_length)
{
assert(names_length > 0);
tdb* const db = tdb_init(); assert(db);
int err = tdb_open(db, input);
if(err) {
REPORT_ERROR("Failed to open TDB. error=%i\n", err);
return 1;
}
tdb_field* field_ids;
err = resolve_fieldids(&field_ids, db, field_names, names_length);
if(err < 0) {
goto free_tdb;
}
tdb_cons* const cons = tdb_cons_init();
assert(cons);
err = tdb_cons_open(cons, output_path, field_names, (unsigned)names_length);
if(err) {
REPORT_ERROR("Failed to create TDB cons. error=%i\n", err);
goto free_ids;
}
TIMED("recode", err, do_recode(cons, db, field_ids, names_length));
if(err)
goto close_cons;
err = tdb_cons_finalize(cons);
if(err) {
REPORT_ERROR("Failed to finalize output DB. error=%i\n", err);
}
close_cons:
tdb_cons_close(cons);
free_ids:
free(field_ids);
free_tdb:
tdb_close(db);
return err;
}
int main()
{
// Ввод текста из стандартного потока ввода
// (при вводе текста из консоли в конце нужно нажать Ctrl-D).
string text = string(istreambuf_iterator<char>(cin), istreambuf_iterator<char>());
// Итератор для вывода слов через пробел.
ostream_iterator<string> owords(cout, " ");
// Разбиение текста на слова.
vector<string> tokens;
TIMED(get_tokens(text, delimiters, tokens));
copy(tokens.begin(), tokens.end(), owords);
cout << endl;
// Составление частотного словаря.
map<string, int> freqdi;
TIMED(get_type_freq(tokens, freqdi);)
for (auto p : freqdi) {
static int cmd_get_all_and_decode(char** dbs, int argc)
{
for(int i = 0; i < argc; ++i) {
const char* path = dbs[i];
tdb* db = tdb_init();
int err = tdb_open(db, path);
if(err) {
printf("Error code %i while opening TDB at %s\n", err, path);
return 1;
}
const unsigned int nfields = (unsigned)tdb_num_fields(db) - 1u;
tdb_field ids[nfields];
for (unsigned int field_id = 0; field_id < nfields; ++field_id)
ids[field_id] = field_id;
TIMED("get_all", err, do_get_all_and_decode(db, path, ids, nfields));
tdb_close(db);
}
return 0;
}
int main(int argc, char **argv) {
InitVars(argc, argv, "segment.cfg");
if (argc != 2) {
DLOG << "Usage: "<<argv[0]<<" INPUT"<<endl;
exit(-1);
}
// Read image
ImageBundle image(argv[1]);
const int& w = image.nx();
const int& h = image.ny();
image.BuildHSV();
// Convert to HSV and mono
WriteHueOnly("out/h_only.png", image.hsv);
// Segment
FHSegmenter segmenter;
TIMED("Segment")
segmenter.Compute(image);
const int num_segments = segmenter.num_segments;
DLOG << "Generated " << num_segments << " segments";
segmenter.OutputSegViz("out/segmentation.png");
// Compute features for each segment
HistSegmentFeatures<TextonLabeller<NhdPixelFeatures> > segftrs;
segftrs.Compute(image.rgb, image.hsv, segmenter.segmentation, num_segments);
segftrs.OutputLabelViz("out/label_map.png");
// Compute similarity matrix
MatF similarity(num_segments, num_segments);
for (int i = 0; i < num_segments; i++) {
similarity[i][i] = 0;
for (int j = i+1; j < num_segments; j++) {
const double ssd = VectorSSD(segftrs.features[i], segftrs.features[j]);
similarity[i][j] = min(1.0/sqrt(ssd), 10);
similarity[j][i] = similarity[i][j];
}
}
similarity /= similarity.MaxValue();
WriteMatrixImageRescaled("out/similarity.png", similarity);
// Generate some vizualizations
const int kNumViz = 15;
ImageRGB<byte> viz(w, h);
vector<PixelRGB<byte> > colors(num_segments);
vector<int> segment_indices;
sorted_order(segmenter.segment_sizes, segment_indices, greater<int>());
for (int i = 0; i < kNumViz; i++) {
// Pick a random pixel and use the segment at that pixel so that
// larger segments are more likely to be chosen
const int root = segment_indices[i];
DREPORT(root);
// Compute colors for each other segment
for (int j = 0; j < num_segments; j++) {
if (j == root) {
colors[j].Set(255, 0, 0);
} else {
const int v = similarity[j][root] * 255;
colors[j].Set(v, v, v);
}
}
// Generate the vizualization
for (int r = 0; r < h; r++) {
PixelRGB<byte>* vizrow = viz[r];
const int* segrow = segmenter.segmentation[r];
for (int c = 0; c < w; c++) {
vizrow[c] = colors[segrow[c]];
}
}
WriteImage("out/sim"+PaddedInt(i,2)+".png", viz);
}
return 0;
}
