1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
#include "dumper.hpp"
#include "../indexer/feature_processor.hpp"
#include "../indexer/classificator.hpp"
#include "../std/vector.hpp"
#include "../std/unordered_map.hpp"
#include "../std/iostream.hpp"
namespace feature
{
class TypesCollector
{
vector<uint32_t> m_currFeatureTypes;
public:
typedef unordered_map<vector<uint32_t>, size_t> value_type;
value_type m_stats;
size_t m_namesCount;
size_t m_totalCount;
TypesCollector() : m_namesCount(0), m_totalCount(0) {}
void operator()(FeatureType & f, uint32_t)
{
++m_totalCount;
if (!f.GetPreferredDrawableName().empty())
++m_namesCount;
m_currFeatureTypes.clear();
f.ForEachTypeRef(*this);
CHECK(!m_currFeatureTypes.empty(), ("Feature without any type???"));
pair<value_type::iterator, bool> found = m_stats.insert(make_pair(m_currFeatureTypes, 1));
if (!found.second)
found.first->second++;
}
void operator()(uint32_t type)
{
m_currFeatureTypes.push_back(type);
}
};
template <class T>
static bool SortFunc(T const & first, T const & second)
{
return first.second > second.second;
}
void DumpTypes(string const & fPath)
{
TypesCollector doClass;
feature::ForEachFromDat(fPath, doClass);
typedef pair<vector<uint32_t>, size_t> stats_elem_type;
typedef vector<stats_elem_type> vec_to_sort;
vec_to_sort vecToSort(doClass.m_stats.begin(), doClass.m_stats.end());
sort(vecToSort.begin(), vecToSort.end(), &SortFunc<stats_elem_type>);
for (vec_to_sort::iterator it = vecToSort.begin(); it != vecToSort.end(); ++it)
{
cout << it->second << " ";
for (size_t i = 0; i < it->first.size(); ++i)
cout << classif().GetFullObjectName(it->first[i]) << " ";
cout << endl;
}
cout << "Total features: " << doClass.m_totalCount << endl;
cout << "Features with names: " << doClass.m_namesCount << endl;
}
class NamesCollector
{
typedef unordered_map<string, size_t> NamesContainerT;
class LangsFunctor
{
public:
vector<string> m_names;
bool operator()(signed char, string const & name)
{
m_names.push_back(name);
return true;
}
};
public:
NamesContainerT m_stats;
void operator()(FeatureType & f, uint32_t)
{
LangsFunctor doLangs;
f.ForEachNameRef(doLangs);
for (size_t i = 0; i < doLangs.m_names.size(); ++i)
{
strings::SimpleTokenizer tok(doLangs.m_names[i], " ");
while (tok)
{
pair<NamesContainerT::iterator, bool> found = m_stats.insert(make_pair(*tok, 1));
if (!found.second)
found.first->second++;
++tok;
}
}
}
};
typedef pair<string, size_t> NameElemT;
void DumpNames(string const & fPath)
{
NamesCollector doClass;
feature::ForEachFromDat(fPath, doClass);
typedef vector<NameElemT> VecToSortT;
VecToSortT vecToSort(doClass.m_stats.begin(), doClass.m_stats.end());
sort(vecToSort.begin(), vecToSort.end(), &SortFunc<NameElemT>);
for (VecToSortT::iterator it = vecToSort.begin(); it != vecToSort.end(); ++it)
cout << it->second << " " << it->first << endl;
}
}
|
