Image::Image(string datos, int size, int nivel, int angulo)
{
Serialized = NULL;
//std::string s = "63 62 70 110 50 40 120 110 12 135 150 175 180 152 200 220";
Mat m =Mat_<uchar>(size,size);
std::istringstream is( datos );
int n;
int c = 0;
while( is >> n ) {
m.at<uchar>((int)(c/size), (c%size)) = n;
c++;
}
m = GLCM::quantify(m, nivel);
features = new double[13];
GenerateFeatures(m, nivel,angulo);
}
void FeatureTracker::SetPose(Vector<3, double> newpose)
{
pose = newpose;
if(bSensing)
{
vector<Feature> fs = TrackFeatures(pose);
double rndMin = MIN_FEATURES * RAND(0.7,1.3);
//printf("%d\n",fs.size());
if(fs.size() < rndMin)
{
GenerateFeatures(rndMin - fs.size(), pose);
}
UpdateMatchedFeatures();
}
}
int main(int argc, char ** argv)
{
google::SetUsageMessage(
"Takes OSM XML data from stdin and creates data and index files in several passes.");
google::ParseCommandLineFlags(&argc, &argv, true);
Platform & pl = GetPlatform();
if (!FLAGS_user_resource_path.empty())
pl.SetResourceDir(FLAGS_user_resource_path);
string const path =
FLAGS_data_path.empty() ? pl.WritableDir() : my::AddSlashIfNeeded(FLAGS_data_path);
feature::GenerateInfo genInfo;
genInfo.m_intermediateDir = FLAGS_intermediate_data_path.empty() ? path
: my::AddSlashIfNeeded(FLAGS_intermediate_data_path);
genInfo.m_targetDir = genInfo.m_tmpDir = path;
/// @todo Probably, it's better to add separate option for .mwm.tmp files.
if (!FLAGS_intermediate_data_path.empty())
{
string const tmpPath = genInfo.m_intermediateDir + "tmp" + my::GetNativeSeparator();
if (pl.MkDir(tmpPath) != Platform::ERR_UNKNOWN)
genInfo.m_tmpDir = tmpPath;
}
genInfo.m_osmFileName = FLAGS_osm_file_name;
genInfo.m_failOnCoasts = FLAGS_fail_on_coasts;
genInfo.m_preloadCache = FLAGS_preload_cache;
genInfo.m_versionDate = static_cast<uint32_t>(FLAGS_planet_version);
if (!FLAGS_node_storage.empty())
genInfo.SetNodeStorageType(FLAGS_node_storage);
if (!FLAGS_osm_file_type.empty())
genInfo.SetOsmFileType(FLAGS_osm_file_type);
// Generating intermediate files
if (FLAGS_preprocess)
{
LOG(LINFO, ("Generating intermediate data ...."));
if (!GenerateIntermediateData(genInfo))
{
return -1;
}
}
// load classificator only if necessary
if (FLAGS_make_coasts || FLAGS_generate_features || FLAGS_generate_geometry ||
FLAGS_generate_index || FLAGS_generate_search_index ||
FLAGS_calc_statistics || FLAGS_type_statistics || FLAGS_dump_types || FLAGS_dump_prefixes ||
FLAGS_check_mwm)
{
classificator::Load();
classif().SortClassificator();
}
// Generate dat file
if (FLAGS_generate_features || FLAGS_make_coasts)
{
LOG(LINFO, ("Generating final data ..."));
genInfo.m_splitByPolygons = FLAGS_split_by_polygons;
genInfo.m_createWorld = FLAGS_generate_world;
genInfo.m_makeCoasts = FLAGS_make_coasts;
genInfo.m_emitCoasts = FLAGS_emit_coasts;
genInfo.m_fileName = FLAGS_output;
genInfo.m_genAddresses = FLAGS_generate_addresses_file;
if (!GenerateFeatures(genInfo))
return -1;
if (FLAGS_generate_world)
{
genInfo.m_bucketNames.push_back(WORLD_FILE_NAME);
genInfo.m_bucketNames.push_back(WORLD_COASTS_FILE_NAME);
}
}
else
{
if (!FLAGS_output.empty())
genInfo.m_bucketNames.push_back(FLAGS_output);
}
// Enumerate over all dat files that were created.
size_t const count = genInfo.m_bucketNames.size();
for (size_t i = 0; i < count; ++i)
{
string const & country = genInfo.m_bucketNames[i];
string const datFile = my::JoinFoldersToPath(path, country + DATA_FILE_EXTENSION);
if (FLAGS_generate_geometry)
{
int mapType = feature::DataHeader::country;
if (country == WORLD_FILE_NAME)
mapType = feature::DataHeader::world;
if (country == WORLD_COASTS_FILE_NAME)
mapType = feature::DataHeader::worldcoasts;
// If error - move to next bucket without index generation.
LOG(LINFO, ("Generating result features for", country));
if (!feature::GenerateFinalFeatures(genInfo, country, mapType))
continue;
LOG(LINFO, ("Generating offsets table for", datFile));
if (!feature::BuildOffsetsTable(datFile))
continue;
}
if (FLAGS_generate_index)
{
LOG(LINFO, ("Generating index for", datFile));
if (!indexer::BuildIndexFromDatFile(datFile, FLAGS_intermediate_data_path + country))
LOG(LCRITICAL, ("Error generating index."));
}
if (FLAGS_generate_search_index)
{
LOG(LINFO, ("Generating search index for ", datFile));
if (!indexer::BuildSearchIndexFromDatFile(datFile, true))
LOG(LCRITICAL, ("Error generating search index."));
}
}
// Create http update list for countries and corresponding files
if (FLAGS_generate_update)
{
LOG(LINFO, ("Updating countries file..."));
update::UpdateCountries(path);
}
string const datFile = path + FLAGS_output + DATA_FILE_EXTENSION;
if (FLAGS_calc_statistics)
{
LOG(LINFO, ("Calculating statistics for ", datFile));
stats::FileContainerStatistic(datFile);
stats::FileContainerStatistic(datFile + ROUTING_FILE_EXTENSION);
stats::MapInfo info;
stats::CalcStatistic(datFile, info);
stats::PrintStatistic(info);
}
if (FLAGS_type_statistics)
{
LOG(LINFO, ("Calculating type statistics for ", datFile));
stats::MapInfo info;
stats::CalcStatistic(datFile, info);
stats::PrintTypeStatistic(info);
}
if (FLAGS_dump_types)
feature::DumpTypes(datFile);
if (FLAGS_dump_prefixes)
feature::DumpPrefixes(datFile);
if (FLAGS_dump_search_tokens)
feature::DumpSearchTokens(datFile);
if (FLAGS_unpack_mwm)
UnpackMwm(datFile);
if (!FLAGS_delete_section.empty())
DeleteSection(datFile, FLAGS_delete_section);
if (FLAGS_generate_packed_borders)
borders::GeneratePackedBorders(path);
if (FLAGS_check_mwm)
check_model::ReadFeatures(datFile);
if (!FLAGS_osrm_file_name.empty() && FLAGS_make_routing)
routing::BuildRoutingIndex(path, FLAGS_output, FLAGS_osrm_file_name);
if (!FLAGS_osrm_file_name.empty() && FLAGS_make_cross_section)
routing::BuildCrossRoutingIndex(path, FLAGS_output, FLAGS_osrm_file_name);
return 0;
}
