void relation( osmium::Relation& relation ) {
const char* bus = relation.tags()["route"];
if(bus && !strcmp(bus, "bus")) {
const char* name = relation.tags().get_value_by_key("ref");
if(!name) name = relation.tags().get_value_by_key("name");
std::cout << name;
osmium::unsigned_object_id_type temp1, temp2;
int db = 0;
for( auto &member : relation.members()){
if(db == 0 && member.type() == osmium::item_type::node) {
temp1 = member.positive_ref();
db++;
} else if(db !=0 && member.type() == osmium::item_type::node){
temp2 = member.positive_ref();
}
}
std::cout << " (" << map[temp1] << " - " << map[temp2] << ")" << std::endl;
for ( auto &member : relation.members()) {
if( member.type() == osmium::item_type::node){
std::cout << " " << locations.get(member.positive_ref()).lat() << ", " << locations.get(member.positive_ref()).lon() << " " << map[member.positive_ref()] << std::endl;
}
}
std::cout << std::endl;
}
}
bool create_area(osmium::memory::Buffer& out_buffer, const osmium::Relation& relation, const std::vector<const osmium::Way*>& members) {
set_num_members(members.size());
osmium::builder::AreaBuilder builder{out_buffer};
builder.initialize_from_object(relation);
const bool area_okay = create_rings();
if (area_okay || config().create_empty_areas) {
if (config().keep_type_tag) {
builder.add_item(relation.tags());
} else {
copy_tags_without_type(builder, relation.tags());
}
}
if (area_okay) {
add_rings_to_area(builder);
}
if (report_ways()) {
for (const osmium::Way* way : members) {
config().problem_reporter->report_way(*way);
}
}
return area_okay || config().create_empty_areas;
}
void relation(osmium::Relation& rel) {
const char* bus = rel.tags() ["route"];
if (bus && !strcmp(bus, "bus")) {
const char* busRef = rel.tags()["ref"];
if (busRef) {
buses.push_back(Bus(busRef, id));
id++;
osmium::RelationMemberList& rml = rel.members();
for (osmium::RelationMember& rm : rml) {
if (rm.type() == osmium::item_type::way) {
std::vector<osmium::Location> tmpVec;
for (auto& nd : ways[rm.ref()]) {
osmium::Location loc = locations.get(nd);
tmpVec.push_back(loc);
}
buses.at(id - 1).locs.push_back(tmpVec);
} else if(rm.type() == osmium::item_type::node &&
!strcmp(rm.role(), "stop")) {
buses.at(id - 1).busStopNames[rm.ref()] = nodes[rm.ref()];
}
}
}
}
}
void relation(const osmium::Relation& relation) {
if (m_write_change_ops) {
open_close_op_tag(relation.visible() ? (relation.version() == 1 ? operation::op_create : operation::op_modify) : operation::op_delete);
}
write_prefix();
m_out += "<relation";
write_meta(relation);
if (relation.tags().empty() && relation.members().empty()) {
m_out += "/>\n";
return;
}
m_out += ">\n";
for (const auto& member : relation.members()) {
write_prefix();
m_out += " <member type=\"";
m_out += item_type_to_name(member.type());
oprintf(m_out, "\" ref=\"%" PRId64 "\" role=\"", member.ref());
xml_string(m_out, member.role());
m_out += "\"/>\n";
}
write_tags(relation.tags());
write_prefix();
m_out += "</relation>\n";
}
void relation(const osmium::Relation& rel)
{
const char *bdy = rel.tags().get_value_by_key("boundary");
if (bdy && !strcmp(bdy, "postal_code"))
{
postcode_boundaries++;
const char *ref = rel.tags().get_value_by_key("ref");
if (ref) postcode[ref]=true;
}
}
// - walk over all relations-versions
// - walk over all relations-nodes
// - Adds the nodes and ways that aren't in node-tracker to a vector
// - if node or way is in the box hit becames true
// - if hit is true and the vector is not empty (it means their are nodes or ways that belong to a relation that has at least one node or way inside the box)
// - Records the id of node or way to outside_node_tracker or outside_way_tracker
void relation(const osmium::Relation& relation) {
bool hit = false;
if (debug) {
std::cerr << "cut_administrative relation " << relation.id() << " v" << relation.version() << "\n";
}
std::vector<const osmium::RelationMember*> members;
std::vector<const osmium::TagList*> tags;
for (auto& tag : relation.tags()) {
if (strcmp(tag.key(), "boundary") == 0 && strcmp(tag.value(), "administrative") == 0)
hit = true;
}
for (const auto& extract : info->extracts) {
if (hit){
if(!extract->relation_tracker.get(relation.id())){
extract->relation_tracker.set(relation.id());
}
//Add only the nodes and ways that were not yet in the respective trackers if hit is true
for (const auto& member : relation.members()) {
if (member.type() == osmium::item_type::way && !extract->way_tracker.get(member.ref())){
extract->way_tracker.set(member.ref());
}
}
}
}
}
void relation ( osmium::Relation& rel ) {
const char* bus = rel.tags() ["route"];
const char* nev;
if ( bus && !strcmp ( bus, "bus" ) ) {
if( rel.tags()["name"])
{
nev = rel.tags()["name"];
}
else
{
nev = rel.tags()["ref"];
}
++stops;
//TODO asdasd
int i {1};
osmium::RelationMemberList& rml = rel.members();
int szam=0;
for ( osmium::RelationMember& rm : rml ) {
i = 1;
if (rm.type() == osmium::item_type::way ) {
for( auto it : way_node_map[rm.ref()] )
{
try {
osmium::Location loc = locations.get ( it );
if ( i++>1 ) {
osmium::geom::Coordinates coords {loc};
szam++;
printf("%.8f %.8f\n",double(coords.y),double(coords.x) );
}
} catch ( std::exception& e ) {
std::cout << "No such node on the map. "<< e.what() << std::endl;
}
}
std::cout << "way\n";
}
}
//std::cout << "way\n";
std::cout << nev << " busz\n";
}
}
// The relation handler is called for each node in the input data.
void relation(const osmium::Relation& relation) {
{
osmium::builder::RelationBuilder builder{m_buffer};
copy_attributes(builder, relation);
copy_tags(builder, relation.tags());
// Copy the relation member list over to the new way.
builder.add_item(relation.members());
}
m_buffer.commit();
}
void relation ( osmium::Relation& rel )
{
++nOSM_relations;
const char* bus = rel.tags() ["route"];
if ( bus && !strcmp ( bus, "bus" ) )
{
++nbuses;
std::string ref_key;
try
{
const char* ref = rel.tags() ["ref"];
if ( ref )
ref_key.append ( ref );
else
ref_key.append ( "Not specified" );
}
catch ( std::exception& e )
{
std::cout << "There is no bus number."<< e.what() << std::endl;
}
osmium::RelationMemberList& rml = rel.members();
for ( osmium::RelationMember& rm : rml )
{
if ( rm.type() == osmium::item_type::way )
{
busWayNodesMap[ref_key].push_back ( rm.ref() );
}
}
}
}
/**
* We are interested in all relations tagged with type=multipolygon
* or type=boundary.
*
* Overwritten from the base class.
*/
bool keep_relation(const osmium::Relation& relation) const {
const char* type = relation.tags().get_value_by_key("type");
// ignore relations without "type" tag
if (!type) {
return false;
}
if ((!strcmp(type, "multipolygon")) || (!strcmp(type, "boundary"))) {
return true;
}
return false;
}
/**
* We are interested in all relations tagged with type=multipolygon
* or type=boundary with at least one way member.
*/
bool new_relation(const osmium::Relation& relation) const {
const char* type = relation.tags().get_value_by_key("type");
// ignore relations without "type" tag
if (!type) {
return false;
}
if ((!std::strcmp(type, "multipolygon")) || (!std::strcmp(type, "boundary"))) {
return std::any_of(relation.members().cbegin(), relation.members().cend(), [](const RelationMember& member) {
return member.type() == osmium::item_type::way;
});
}
return false;
}
int output_pgsql_t::relation_add(osmium::Relation const &rel)
{
char const *type = rel.tags()["type"];
/* Must have a type field or we ignore it */
if (!type)
return 0;
/* Only a limited subset of type= is supported, ignore other */
if (strcmp(type, "route") != 0 && strcmp(type, "multipolygon") != 0
&& strcmp(type, "boundary") != 0) {
return 0;
}
return pgsql_process_relation(rel);
}
void relation(const osmium::Relation& relation) {
m_out << "r";
write_meta(relation);
m_out << " M";
int n=0;
for (const auto& member : relation.members()) {
if (n++ != 0) {
m_out << ",";
}
m_out << item_type_to_char(member.type())
<< member.ref()
<< "!"
<< member.role();
}
write_tags(relation.tags());
m_out << "\n";
::write(this->fd(), m_out.str().c_str(), m_out.str().size());
m_out.str("");
}
/**
* Tries to parse a relation as a turn restriction. This can fail for a number of
* reasons. The return type is a boost::optional<T>.
*
* Some restrictions can also be ignored: See the ```get_restrictions``` function
* in the corresponding profile. We use it for both namespacing restrictions, as in
* restriction:motorcar as well as whitelisting if its in except:motorcar.
*/
std::vector<InputRestrictionContainer>
RestrictionParser::TryParse(const osmium::Relation &relation) const
{
std::vector<InputRestrictionContainer> parsed_restrictions;
// return if turn restrictions should be ignored
if (!use_turn_restrictions)
{
return {};
}
osmium::tags::KeyFilter filter(false);
filter.add(true, "restriction");
if (parse_conditionals)
{
filter.add(true, "restriction:conditional");
for (const auto &namespaced : restrictions)
{
filter.add(true, "restriction:" + namespaced + ":conditional");
}
}
// Not only use restriction= but also e.g. restriction:motorcar=
// Include restriction:{mode}:conditional if flagged
for (const auto &namespaced : restrictions)
{
filter.add(true, "restriction:" + namespaced);
}
const osmium::TagList &tag_list = relation.tags();
osmium::tags::KeyFilter::iterator fi_begin(filter, tag_list.begin(), tag_list.end());
osmium::tags::KeyFilter::iterator fi_end(filter, tag_list.end(), tag_list.end());
// if it's not a restriction, continue;
if (std::distance(fi_begin, fi_end) == 0)
{
return {};
}
// check if the restriction should be ignored
const char *except = relation.get_value_by_key("except");
if (except != nullptr && ShouldIgnoreRestriction(except))
{
return {};
}
bool is_only_restriction = false;
for (; fi_begin != fi_end; ++fi_begin)
{
const std::string key(fi_begin->key());
const std::string value(fi_begin->value());
// documented OSM restriction tags start either with only_* or no_*;
// check and return on these values, and ignore unrecognized values
if (value.find("only_") == 0)
{
is_only_restriction = true;
}
else if (value.find("no_") == 0)
{
is_only_restriction = false;
}
else // unrecognized value type
{
return {};
}
}
InputRestrictionContainer restriction_container(is_only_restriction);
for (const auto &member : relation.members())
{
const char *role = member.role();
if (strcmp("from", role) != 0 && strcmp("to", role) != 0 && strcmp("via", role) != 0)
{
continue;
}
switch (member.type())
{
case osmium::item_type::node:
// Make sure nodes appear only in the role if a via node
if (0 == strcmp("from", role) || 0 == strcmp("to", role))
{
continue;
}
BOOST_ASSERT(0 == strcmp("via", role));
// set via node id
restriction_container.restriction.via.node = member.ref();
break;
case osmium::item_type::way:
BOOST_ASSERT(0 == strcmp("from", role) || 0 == strcmp("to", role) ||
0 == strcmp("via", role));
if (0 == strcmp("from", role))
{
restriction_container.restriction.from.way = member.ref();
}
else if (0 == strcmp("to", role))
{
restriction_container.restriction.to.way = member.ref();
}
// else if (0 == strcmp("via", role))
// {
// not yet suppported
// restriction_container.restriction.via.way = member.ref();
// }
break;
case osmium::item_type::relation:
// not yet supported, but who knows what the future holds...
break;
default:
// shouldn't ever happen
break;
}
}
// parse conditional tags
if (parse_conditionals)
{
osmium::tags::KeyFilter::iterator fi_begin(filter, tag_list.begin(), tag_list.end());
osmium::tags::KeyFilter::iterator fi_end(filter, tag_list.end(), tag_list.end());
for (; fi_begin != fi_end; ++fi_begin)
{
const std::string key(fi_begin->key());
const std::string value(fi_begin->value());
// Parse condition and add independent value/condition pairs
const auto &parsed = osrm::util::ParseConditionalRestrictions(value);
if (parsed.empty())
continue;
for (const auto &p : parsed)
{
std::vector<util::OpeningHours> hours = util::ParseOpeningHours(p.condition);
// found unrecognized condition, continue
if (hours.empty())
return {};
restriction_container.restriction.condition = std::move(hours);
}
}
}
// push back a copy of turn restriction
if (restriction_container.restriction.via.node != SPECIAL_NODEID &&
restriction_container.restriction.from.node != SPECIAL_NODEID &&
restriction_container.restriction.to.node != SPECIAL_NODEID)
parsed_restrictions.push_back(restriction_container);
return parsed_restrictions;
}
/**
* Tries to parse a relation as a turn restriction. This can fail for a number of
* reasons. The return type is a boost::optional<T>.
*
* Some restrictions can also be ignored: See the ```get_restrictions``` function
* in the corresponding profile. We use it for both namespacing restrictions, as in
* restriction:motorcar as well as whitelisting if its in except:motorcar.
*/
boost::optional<InputRestrictionContainer>
RestrictionParser::TryParse(const osmium::Relation &relation) const
{
// return if turn restrictions should be ignored
if (!use_turn_restrictions)
{
return {};
}
osmium::tags::KeyFilter filter(false);
filter.add(true, "restriction");
// Not only use restriction= but also e.g. restriction:motorcar=
for (const auto &namespaced : restrictions)
filter.add(true, "restriction:" + namespaced);
const osmium::TagList &tag_list = relation.tags();
osmium::tags::KeyFilter::iterator fi_begin(filter, tag_list.begin(), tag_list.end());
osmium::tags::KeyFilter::iterator fi_end(filter, tag_list.end(), tag_list.end());
// if it's not a restriction, continue;
if (std::distance(fi_begin, fi_end) == 0)
{
return {};
}
// check if the restriction should be ignored
const char *except = relation.get_value_by_key("except");
if (except != nullptr && ShouldIgnoreRestriction(except))
{
return {};
}
bool is_only_restriction = false;
for (; fi_begin != fi_end; ++fi_begin)
{
const std::string key(fi_begin->key());
const std::string value(fi_begin->value());
// documented OSM restriction tags start either with only_* or no_*;
// check and return on these values, and ignore unrecognized values
if (value.find("only_") == 0)
{
is_only_restriction = true;
}
else if (value.find("no_") == 0)
{
is_only_restriction = false;
}
else // unrecognized value type
{
return {};
}
}
InputRestrictionContainer restriction_container(is_only_restriction);
for (const auto &member : relation.members())
{
const char *role = member.role();
if (strcmp("from", role) != 0 && strcmp("to", role) != 0 && strcmp("via", role) != 0)
{
continue;
}
switch (member.type())
{
case osmium::item_type::node:
// Make sure nodes appear only in the role if a via node
if (0 == strcmp("from", role) || 0 == strcmp("to", role))
{
continue;
}
BOOST_ASSERT(0 == strcmp("via", role));
// set via node id
restriction_container.restriction.via.node = member.ref();
break;
case osmium::item_type::way:
BOOST_ASSERT(0 == strcmp("from", role) || 0 == strcmp("to", role) ||
0 == strcmp("via", role));
if (0 == strcmp("from", role))
{
restriction_container.restriction.from.way = member.ref();
}
else if (0 == strcmp("to", role))
{
restriction_container.restriction.to.way = member.ref();
}
// else if (0 == strcmp("via", role))
// {
// not yet suppported
// restriction_container.restriction.via.way = member.ref();
// }
break;
case osmium::item_type::relation:
// not yet supported, but who knows what the future holds...
break;
default:
// shouldn't ever happen
break;
}
}
return boost::make_optional(std::move(restriction_container));
}
void middle_pgsql_t::relations_set(osmium::Relation const &rel)
{
idlist_t parts[3];
for (auto const &m : rel.members()) {
parts[osmium::item_type_to_nwr_index(m.type())].push_back(m.ref());
}
copy_buffer.reserve(rel.members().byte_size() * 2 + rel.tags().byte_size() + 128);
// Params: id, way_off, rel_off, parts, members, tags */
const char *paramValues[6] = { copy_buffer.c_str(), };
bool copy = rel_table->copyMode;
char delim = copy ? '\t' : '\0';
copy_buffer = std::to_string(rel.id());
copy_buffer+= delim;
paramValues[1] = paramValues[0] + copy_buffer.size();
copy_buffer += std::to_string(parts[0].size());
copy_buffer+= delim;
paramValues[2] = paramValues[0] + copy_buffer.size();
copy_buffer += std::to_string(parts[0].size() + parts[1].size());
copy_buffer+= delim;
paramValues[3] = paramValues[0] + copy_buffer.size();
if (rel.members().empty()) {
copy_buffer += "{}";
} else {
copy_buffer += "{";
for (int i = 0; i < 3; ++i) {
for (auto it : parts[i]) {
copy_buffer += std::to_string(it);
copy_buffer += ',';
}
}
copy_buffer[copy_buffer.size() - 1] = '}';
}
copy_buffer+= delim;
if (rel.members().empty()) {
paramValues[4] = nullptr;
copy_buffer += "\\N";
} else {
paramValues[4] = paramValues[0] + copy_buffer.size();
copy_buffer += "{";
for (auto const &m : rel.members()) {
copy_buffer += '"';
copy_buffer += osmium::item_type_to_char(m.type());
copy_buffer += std::to_string(m.ref());
copy_buffer += "\",\"";
buffer_store_string(m.role(), copy);
copy_buffer += "\",";
}
copy_buffer[copy_buffer.size() - 1] = '}';
}
copy_buffer+= delim;
if (rel.tags().empty() && !out_options->extra_attributes) {
paramValues[5] = nullptr;
copy_buffer += "\\N";
} else {
paramValues[5] = paramValues[0] + copy_buffer.size();
buffer_store_tags(rel, out_options->extra_attributes, copy);
}
if (copy) {
copy_buffer+= '\n';
pgsql_CopyData(__FUNCTION__, rel_table->sql_conn, copy_buffer);
} else {
buffer_correct_params(paramValues, 6);
pgsql_execPrepared(rel_table->sql_conn, "insert_rel", 6,
(const char * const *)paramValues, PGRES_COMMAND_OK);
}
}
mapbox::util::optional<InputRestrictionContainer>
RestrictionParser::TryParse(const osmium::Relation &relation) const
{
// return if turn restrictions should be ignored
if (!use_turn_restrictions)
{
return mapbox::util::optional<InputRestrictionContainer>();
}
osmium::tags::KeyPrefixFilter filter(false);
filter.add(true, "restriction");
const osmium::TagList &tag_list = relation.tags();
osmium::tags::KeyPrefixFilter::iterator fi_begin(filter, tag_list.begin(), tag_list.end());
osmium::tags::KeyPrefixFilter::iterator fi_end(filter, tag_list.end(), tag_list.end());
// if it's a restriction, continue;
if (std::distance(fi_begin, fi_end) == 0)
{
return mapbox::util::optional<InputRestrictionContainer>();
}
// check if the restriction should be ignored
const char *except = relation.get_value_by_key("except");
if (except != nullptr && ShouldIgnoreRestriction(except))
{
return mapbox::util::optional<InputRestrictionContainer>();
}
bool is_only_restriction = false;
for (auto iter = fi_begin; iter != fi_end; ++iter)
{
if (std::string("restriction") == iter->key() ||
std::string("restriction::hgv") == iter->key())
{
const std::string restriction_value(iter->value());
if (restriction_value.find("only_") == 0)
{
is_only_restriction = true;
}
}
}
InputRestrictionContainer restriction_container(is_only_restriction);
for (const auto &member : relation.members())
{
const char *role = member.role();
if (strcmp("from", role) != 0 && strcmp("to", role) != 0 && strcmp("via", role) != 0)
{
continue;
}
switch (member.type())
{
case osmium::item_type::node:
// Make sure nodes appear only in the role if a via node
if (0 == strcmp("from", role) || 0 == strcmp("to", role))
{
continue;
}
BOOST_ASSERT(0 == strcmp("via", role));
// set via node id
restriction_container.restriction.via.node = member.ref();
break;
case osmium::item_type::way:
BOOST_ASSERT(0 == strcmp("from", role) || 0 == strcmp("to", role) ||
0 == strcmp("via", role));
if (0 == strcmp("from", role))
{
restriction_container.restriction.from.way = member.ref();
}
else if (0 == strcmp("to", role))
{
restriction_container.restriction.to.way = member.ref();
}
// else if (0 == strcmp("via", role))
// {
// not yet suppported
// restriction_container.restriction.via.way = member.ref();
// }
break;
case osmium::item_type::relation:
// not yet supported, but who knows what the future holds...
break;
default:
// shouldn't ever happen
break;
}
}
return mapbox::util::optional<InputRestrictionContainer>(restriction_container);
}