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