289 lines
9.2 KiB
C++
289 lines
9.2 KiB
C++
#include "extractor/restriction_parser.hpp"
|
|
#include "extractor/profile_properties.hpp"
|
|
|
|
#include "util/conditional_restrictions.hpp"
|
|
#include "util/integer_range.hpp"
|
|
#include "util/log.hpp"
|
|
|
|
#include <boost/algorithm/string/predicate.hpp>
|
|
#include <boost/optional/optional.hpp>
|
|
#include <boost/ref.hpp>
|
|
|
|
#include <osmium/osm.hpp>
|
|
|
|
#include <algorithm>
|
|
|
|
namespace osrm
|
|
{
|
|
namespace extractor
|
|
{
|
|
|
|
RestrictionParser::RestrictionParser(bool use_turn_restrictions_,
|
|
bool parse_conditionals_,
|
|
const std::vector<std::string> &restrictions_)
|
|
: use_turn_restrictions(use_turn_restrictions_), parse_conditionals(parse_conditionals_),
|
|
restrictions(restrictions_.begin(), restrictions_.end()), filter(false)
|
|
{
|
|
if (use_turn_restrictions)
|
|
{
|
|
const unsigned count = restrictions.size();
|
|
if (count > 0)
|
|
{
|
|
util::Log() << "Found " << count << " turn restriction tags:";
|
|
for (const std::string &str : restrictions)
|
|
{
|
|
util::Log() << " " << str;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
util::Log() << "Found no turn restriction tags";
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tries to parse a relation as a turn restriction. This can fail for a number of
|
|
* reasons. The return type is a std::vector<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<InputTurnRestriction>
|
|
RestrictionParser::TryParse(const osmium::Relation &relation) const
|
|
{
|
|
// return if turn restrictions should be ignored
|
|
if (!use_turn_restrictions)
|
|
{
|
|
return {};
|
|
}
|
|
|
|
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 (fi_begin == fi_end)
|
|
{
|
|
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;
|
|
bool is_multi_from = false;
|
|
bool is_multi_to = false;
|
|
|
|
std::vector<util::OpeningHours> condition;
|
|
|
|
for (; fi_begin != fi_end; ++fi_begin)
|
|
{
|
|
auto value = fi_begin->value();
|
|
|
|
// documented OSM restriction tags start either with only_* or no_*;
|
|
// check and return on these values, and ignore no_*_on_red or unrecognized values
|
|
if (boost::algorithm::starts_with(value, "only_"))
|
|
{
|
|
is_only_restriction = true;
|
|
}
|
|
else if (boost::algorithm::starts_with(value, "no_") &&
|
|
!boost::algorithm::ends_with(value, "_on_red"))
|
|
{
|
|
is_only_restriction = false;
|
|
if (boost::algorithm::starts_with(value, "no_exit"))
|
|
{
|
|
is_multi_to = true;
|
|
}
|
|
else if (boost::algorithm::starts_with(value, "no_entry"))
|
|
{
|
|
is_multi_from = true;
|
|
}
|
|
}
|
|
else // unrecognized value type
|
|
{
|
|
return {};
|
|
}
|
|
|
|
if (parse_conditionals)
|
|
{
|
|
// 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 {};
|
|
|
|
condition = std::move(hours);
|
|
}
|
|
}
|
|
}
|
|
|
|
constexpr auto INVALID_OSM_ID = std::numeric_limits<std::uint64_t>::max();
|
|
std::vector<OSMWayID> from_ways;
|
|
auto via_node = INVALID_OSM_ID;
|
|
std::vector<OSMWayID> via_ways;
|
|
std::vector<OSMWayID> to_ways;
|
|
bool is_node_restriction = true;
|
|
|
|
for (const auto &member : relation.members())
|
|
{
|
|
const char *role = member.role();
|
|
const bool is_from_role = strcmp("from", role) == 0;
|
|
const bool is_to_role = strcmp("to", role) == 0;
|
|
const bool is_via_role = strcmp("via", role) == 0;
|
|
|
|
if (!is_from_role && !is_to_role && !is_via_role)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
switch (member.type())
|
|
{
|
|
case osmium::item_type::node:
|
|
{
|
|
|
|
// Make sure nodes appear only in the role if a via node
|
|
if (is_from_role || is_to_role)
|
|
{
|
|
continue;
|
|
}
|
|
BOOST_ASSERT(is_via_role);
|
|
via_node = static_cast<std::uint64_t>(member.ref());
|
|
is_node_restriction = true;
|
|
// set via node id
|
|
break;
|
|
}
|
|
case osmium::item_type::way:
|
|
BOOST_ASSERT(is_from_role || is_to_role || is_via_role);
|
|
if (is_from_role)
|
|
{
|
|
from_ways.push_back({static_cast<std::uint64_t>(member.ref())});
|
|
}
|
|
else if (is_to_role)
|
|
{
|
|
to_ways.push_back({static_cast<std::uint64_t>(member.ref())});
|
|
}
|
|
else if (is_via_role)
|
|
{
|
|
via_ways.push_back({static_cast<std::uint64_t>(member.ref())});
|
|
is_node_restriction = false;
|
|
}
|
|
break;
|
|
case osmium::item_type::relation:
|
|
// not yet supported, but who knows what the future holds...
|
|
break;
|
|
default:
|
|
// shouldn't ever happen
|
|
break;
|
|
}
|
|
}
|
|
|
|
std::vector<InputTurnRestriction> restriction_containers;
|
|
if (!from_ways.empty() && (via_node != INVALID_OSM_ID || !via_ways.empty()) && !to_ways.empty())
|
|
{
|
|
if (from_ways.size() > 1 && !is_multi_from)
|
|
{
|
|
util::Log(logDEBUG) << "Parsed restriction " << relation.id()
|
|
<< " unexpectedly contains " << from_ways.size()
|
|
<< " from ways, skipping...";
|
|
return {};
|
|
}
|
|
if (to_ways.size() > 1 && !is_multi_to)
|
|
{
|
|
util::Log(logDEBUG) << "Parsed restriction " << relation.id()
|
|
<< " unexpectedly contains " << to_ways.size()
|
|
<< " to ways, skipping...";
|
|
return {};
|
|
}
|
|
// Internally restrictions are represented with one 'from' and one 'to' way.
|
|
// Therefore, we need to convert a multi from/to restriction into multiple restrictions.
|
|
for (const auto &from : from_ways)
|
|
{
|
|
for (const auto &to : to_ways)
|
|
{
|
|
InputTurnRestriction restriction;
|
|
restriction.is_only = is_only_restriction;
|
|
restriction.condition = condition;
|
|
if (is_node_restriction)
|
|
{
|
|
// template struct requires bracket for ID initialisation :(
|
|
restriction.turn_path.node_or_way = InputViaNodePath{{from}, {via_node}, {to}};
|
|
}
|
|
else
|
|
{
|
|
// template struct requires bracket for ID initialisation :(
|
|
restriction.turn_path.node_or_way = InputViaWayPath{{from}, via_ways, {to}};
|
|
}
|
|
restriction_containers.push_back(std::move(restriction));
|
|
}
|
|
}
|
|
}
|
|
return restriction_containers;
|
|
}
|
|
|
|
bool RestrictionParser::ShouldIgnoreRestriction(const std::string &except_tag_string) const
|
|
{
|
|
// should this restriction be ignored? yes if there's an overlap between:
|
|
// a) the list of modes in the except tag of the restriction
|
|
// (except_tag_string), eg: except=bus;bicycle
|
|
// b) the lua profile defines a hierarchy of modes,
|
|
// eg: [access, vehicle, bicycle]
|
|
|
|
if (except_tag_string.empty())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// split `except_tag_string` by semicolon and check if any of items is in `restrictions`
|
|
std::string current_string;
|
|
for (auto index : util::irange<size_t>(0, except_tag_string.size()))
|
|
{
|
|
const auto ch = except_tag_string[index];
|
|
if (ch != ';')
|
|
{
|
|
current_string += ch;
|
|
}
|
|
else
|
|
{
|
|
if (restrictions.find(current_string) != restrictions.end())
|
|
{
|
|
return true;
|
|
}
|
|
current_string.clear();
|
|
}
|
|
}
|
|
return restrictions.find(current_string) != restrictions.end();
|
|
}
|
|
} // namespace extractor
|
|
} // namespace osrm
|