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( 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;
}
// - 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(const osmium::Relation& relation) {
if (m_max_relation_id == relation.id()) {
throw out_of_order_error{"Relation ID twice in input. Maybe you are using a history or change file?", relation.id()};
}
if (id_order{}(relation.id(), m_max_relation_id)) {
throw out_of_order_error{"Relation IDs out of order.", relation.id()};
}
m_max_relation_id = relation.id();
}
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 relation-versions
// - walk over all bboxes
// - if the relation-id is recorded in the bboxes relation-tracker
// - send the relation to the bboxes writer
void relation(const osmium::Relation& relation) {
if (debug) {
std::cerr << "softcut relation " << relation.positive_id() << " v" << relation.version() << "\n";
}
for (const auto& extract : info->extracts) {
if (extract->relation_tracker.get(relation.positive_id())) {
extract->write(relation);
}
}
}
// 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 parse_osmium_t::relation(osmium::Relation& rel)
{
if (rel.deleted()) {
m_data->relation_delete(rel.id());
} else {
if (m_append) {
m_data->relation_modify(rel);
} else {
m_data->relation_add(rel);
}
}
m_stats.add_rel(rel.id());
}
/**
* 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 osmdata_t::relation_modify(osmium::Relation const &rel)
{
slim_middle_t *slim = dynamic_cast<slim_middle_t *>(mid.get());
slim->relations_delete(rel.id());
slim->relations_set(rel);
int status = 0;
for (auto& out: outs) {
status |= out->relation_modify(rel);
}
slim->relation_changed(rel.id());
return status;
}
osmium::osm_entity_bits::type CommandAddRefs::add_members(const osmium::Relation& relation) {
osmium::osm_entity_bits::type read_types = osmium::osm_entity_bits::nothing;
for (const auto& member : relation.members()) {
switch (member.type()) {
case osmium::item_type::node:
m_node_ids.insert(member.ref());
break;
case osmium::item_type::way:
if (m_way_ids.count(member.ref()) == 0) {
m_way_ids.insert(member.ref());
read_types |= osmium::osm_entity_bits::way;
}
break;
case osmium::item_type::relation:
if (m_relation_ids.count(member.ref()) == 0) {
m_relation_ids.insert(member.ref());
read_types |= osmium::osm_entity_bits::relation;
}
break;
default:
break;
}
}
return read_types;
}
void relation(const osmium::Relation& relation) {
*m_out += 'r';
write_meta(relation);
*m_out += " M";
if (!relation.members().empty()) {
auto it = relation.members().begin();
relation_member(*it);
for (++it; it != relation.members().end(); ++it) {
*m_out += ',';
relation_member(*it);
}
}
*m_out += '\n';
}
/**
* Assemble an area from the given relation and its members.
* The resulting area is put into the out_buffer.
*
* @returns false if there was some kind of error building the
* area(s), true otherwise.
*/
bool operator()(const osmium::Relation& relation, const std::vector<const osmium::Way*>& members, osmium::memory::Buffer& out_buffer) {
if (!config().create_new_style_polygons) {
return true;
}
assert(relation.cmembers().size() >= members.size());
if (config().problem_reporter) {
config().problem_reporter->set_object(osmium::item_type::relation, relation.id());
}
if (relation.members().empty()) {
++stats().no_way_in_mp_relation;
return false;
}
++stats().from_relations;
stats().invalid_locations = segment_list().extract_segments_from_ways(config().problem_reporter,
stats().duplicate_nodes,
stats().duplicate_ways,
relation,
members);
if (!config().ignore_invalid_locations && stats().invalid_locations > 0) {
return false;
}
stats().member_ways = members.size();
if (stats().member_ways == 1) {
++stats().single_way_in_mp_relation;
}
if (config().debug_level > 0) {
std::cerr << "\nAssembling relation " << relation.id() << " containing " << members.size() << " way members with " << segment_list().size() << " nodes\n";
}
// Now create the Area object and add the attributes and tags
// from the relation.
bool okay = create_area(out_buffer, relation, members);
if (okay) {
out_buffer.commit();
} else {
out_buffer.rollback();
}
return okay;
}
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";
}
}
/**
* Extract all segments from all ways that make up this
* multipolygon relation and add them to the list.
*/
void extract_segments_from_ways(const osmium::Relation& relation, const std::vector<size_t>& members, const osmium::memory::Buffer& in_buffer) {
auto member_it = relation.members().begin();
for (size_t offset : members) {
const osmium::Way& way = in_buffer.get<const osmium::Way>(offset);
extract_segments_from_way(way, member_it->role());
++member_it;
}
}
void relation(const osmium::Relation& relation) {
for (const auto& member : relation.members()) {
switch (member.type()) {
case osmium::item_type::node:
m_index_n2r.set(member.positive_ref(), relation.positive_id());
break;
case osmium::item_type::way:
m_index_w2r.set(member.positive_ref(), relation.positive_id());
break;
case osmium::item_type::relation:
m_index_r2r.set(member.positive_ref(), relation.positive_id());
break;
default:
break;
}
}
}
/**
* This is called when a relation is complete, ie. all members
* were found in the input. It will build the area using the
* assembler.
*/
void complete_relation(const osmium::Relation& relation) {
std::vector<const osmium::Way*> ways;
ways.reserve(relation.members().size());
for (const auto& member : relation.members()) {
if (member.ref() != 0) {
ways.push_back(this->get_member_way(member.ref()));
assert(ways.back() != nullptr);
}
}
try {
TAssembler assembler{m_assembler_config};
assembler(relation, ways, this->buffer());
m_stats += assembler.stats();
} catch (const osmium::invalid_location&) {
// XXX ignore
}
}
inline void for_each_member(const osmium::Relation& relation, const std::vector<const osmium::Way*>& ways, F&& func) {
auto way_it = ways.cbegin();
for (const osmium::RelationMember& member : relation.members()) {
if (member.type() == osmium::item_type::way) {
assert(way_it != ways.cend());
func(member, **way_it);
++way_it;
}
}
}
int output_pgsql_t::relation_modify(osmium::Relation const &rel)
{
if( !m_options.slim )
{
fprintf( stderr, "Cannot apply diffs unless in slim mode\n" );
util::exit_nicely();
}
relation_delete(rel.id());
relation_add(rel);
return 0;
}
void complete_relation(const osmium::Relation& relation) noexcept {
for (const auto& member : relation.members()) {
if (member.type() == osmium::item_type::node) {
++count_nodes;
const auto* node = get_member_node(member.ref());
REQUIRE(node);
buffer().add_item(*node);
buffer().commit();
}
}
}
void erelation(extract_data& e, const osmium::Relation& relation) {
for (const auto& member : relation.members()) {
switch (member.type()) {
case osmium::item_type::node:
if (e.node_ids.get(member.positive_ref())) {
e.relation_ids.set(relation.positive_id());
return;
}
break;
case osmium::item_type::way:
if (e.way_ids.get(member.positive_ref())) {
e.relation_ids.set(relation.positive_id());
return;
}
break;
default:
break;
}
}
}
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() );
}
}
}
}
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("");
}
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";
}
// - walk over all relation-versions
// - walk over all bboxes
// - walk over all relation-members
// - if the relation-member is recorded in the bboxes node- or way-tracker
// - record its id in the bboxes relation-tracker
void relation(const osmium::Relation& relation) {
if (first_relation) {
write_way_extra_nodes();
first_relation = false;
}
if (debug) {
std::cerr << "softcut relation " << relation.positive_id() << " v" << relation.version() << "\n";
}
for (const auto& extract : info->extracts) {
bool hit = false;
for (const auto& member : relation.members()) {
if (!hit && (
(member.type() == osmium::item_type::node && extract->node_tracker.get(member.positive_ref())) ||
(member.type() == osmium::item_type::way && extract->way_tracker.get(member.positive_ref())) ||
(member.type() == osmium::item_type::relation && extract->relation_tracker.get(member.positive_ref()))
)) {
if (debug) std::cerr << "relation has a member (" << member.type() << " " << member.positive_ref() << ") inside extract, recording in relation_tracker\n";
hit = true;
extract->relation_tracker.set(relation.positive_id());
}
if (member.type() == osmium::item_type::relation) {
if (debug) {
std::cerr << "recording cascading-pair: " << member.positive_ref() << " -> " << relation.positive_id() << "\n";
}
info->cascading_relations_tracker.insert(std::make_pair(member.positive_ref(), relation.positive_id()));
}
}
if (hit) {
cascading_relations(extract, relation.positive_id());
}
}
}
/**
* 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;
}
/***
* Iterate through members. Create linestrings of each. First as GEOS
* linestring to union them later. Then as ORG linestring to insert
* them into table ways.
*/
void create_ways(const osmium::Relation &relation,
const osmium::object_id_type relation_id,
bool &contains_nowaterway_ways,
vector<geos::geom::Geometry *> *linestrings) {
for (auto& member : relation.members()) {
if (member_is_valid(member)) {
const osmium::Way& way = way_from(member);
linestring_type *linestr = nullptr;
try {
linestr = osmium_geos_factory.create_linestring(way,
osmium::geom::use_nodes::unique,
osmium::geom::direction::forward).release();
} catch (osmium::geometry_error) {
insert_way_error(way);
continue;
} catch (...) {
cerr << "Error at way: " << way.id() << endl;
cerr << " Unexpected error" << endl;
continue;
}
if (linestr) {
linestrings->push_back(linestr);
} else {
continue;
}
if (TagCheck::has_waterway_tag(way)) {
contains_nowaterway_ways = true;
}
OGRGeometry *ogr_linestring = nullptr;
ogr_linestring = geos2ogr(linestr);
try {
ds.insert_way_feature(ogr_linestring, way, relation_id);
} catch (osmium::geometry_error&) {
cerr << "Inserting to table failed for way: "
<< way.id() << endl;
} catch (...) {
cerr << "Inserting to table failed for way: "
<< way.id() << endl;;
cerr << " Unexpected error" << endl;
}
OGRGeometryFactory::destroyGeometry(ogr_linestring);
}
}
}
/**
* Extract all segments from all ways that make up this
* multipolygon relation and add them to the list.
*/
uint32_t extract_segments_from_ways(osmium::area::ProblemReporter* problem_reporter, const osmium::Relation& relation, const std::vector<const osmium::Way*>& members) {
assert(relation.members().size() >= members.size());
const size_t num_segments = get_num_segments(members);
if (problem_reporter) {
problem_reporter->set_nodes(num_segments);
}
m_segments.reserve(num_segments);
uint32_t duplicate_nodes = 0;
for_each_member(relation, members, [this, &problem_reporter, &duplicate_nodes](const osmium::RelationMember& member, const osmium::Way& way) {
duplicate_nodes += extract_segments_from_way_impl(problem_reporter, way, parse_role(member.role()));
});
return duplicate_nodes;
}
size_t middle_ram_t::rel_way_members_get(osmium::Relation const &rel,
rolelist_t *roles,
osmium::memory::Buffer &buffer) const
{
size_t count = 0;
for (auto const &m : rel.members()) {
if (m.type() == osmium::item_type::way && ways_get(m.ref(), buffer)) {
if (roles) {
roles->emplace_back(m.role());
}
++count;
}
}
return count;
}