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