Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Merge pull request #2707 from oxidase/left_side_driving

Browse Source 
Left side driving
This commit is contained in:
Patrick Niklaus 2016-08-05 18:09:10 +02:00 committed by GitHub
commit 677306eeee
14 changed files with 203 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -2,6 +2,7 @@
Changes from 5.3.0
- Profiles
- includes library guidance.lua that offers preliminary configuration on guidance.
- added left_hand_driving flag in global profile properties
- Guidance
- Handle Access tags for lanes, only considering valid lanes in lane-guidance (think car | car | bike | car)
- API:

31
features/guidance/anticipate-lanes.feature
View File

@ -365,6 +365,37 @@ Feature: Turn Lane Guidance
| x,c | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,, |
| x,a | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,, |
@anticipate
Scenario: No Lanes for Roundabouts, see #2626
Given the profile "lhs"
And the node map
| | | a | | |
| | | b | | |
| h | c | | g | |
| | | | | |
| | d | | f | |
| | | e | | |
| x | | | | y |
And the ways
| nodes | turn:lanes:forward | highway | junction |
| ab | slight_left\|slight_left | primary | |
| bg | | primary | roundabout |
| gf | | primary | roundabout |
| fe | | primary | roundabout |
| ed | | primary | roundabout |
| dc | slight_left | primary | roundabout |
| cb | | primary | roundabout |
| ch | | primary | |
| ex | | primary | |
| dx | | primary | |
| gy | | primary | |
| fy | | primary | |
When I route I should get
| waypoints | route | turns | lanes |
| a,h | ab,ch,ch | depart,roundabout-exit-5,arrive | ,, |
@anticipate
Scenario: No Lanes for Roundabouts, see #2626
Given the node map

83
features/testbot/side_bias.feature Normal file
View File

@ -0,0 +1,83 @@
@routing @testbot @sidebias
Feature: Testbot - side bias
Scenario: Left hand bias
Given the profile "lhs"
And the node map
| a | | b | | c |
| | | | | |
| | | d | | |
And the ways
| nodes |
| ab |
| bc |
| bd |
When I route I should get
| from | to | route | time |
| d | a | bd,ab,ab | 82s +-1 |
| d | c | bd,bc,bc | 100s +-1 |
Scenario: Right hand bias
Given the profile "rhs"
And the node map
| a | | b | | c |
| | | | | |
| | | d | | |
And the ways
| nodes |
| ab |
| bc |
| bd |
When I route I should get
| from | to | route | time |
| d | a | bd,ab,ab | 100s +-1 |
| d | c | bd,bc,bc | 82s +-1 |
Scenario: Roundabout exit counting for left sided driving
Given the profile "lhs"
And a grid size of 10 meters
And the node map
| | | a | | |
| | | b | | |
| h | g | | c | d |
| | | e | | |
| | | f | | |
And the ways
| nodes | junction |
| ab | |
| cd | |
| ef | |
| gh | |
| bcegb | roundabout |
When I route I should get
| waypoints | route | turns |
| a,d | ab,cd,cd | depart,roundabout-exit-1,arrive |
| a,f | ab,ef,ef | depart,roundabout-exit-2,arrive |
| a,h | ab,gh,gh | depart,roundabout-exit-3,arrive |
Scenario: Mixed Entry and Exit
Given the profile "lhs"
And a grid size of 10 meters
And the node map
| | c | | a | |
| j | | b | | f |
| | k | | e | |
| l | | h | | d |
| | g | | i | |
And the ways
| nodes | junction | oneway |
| cba | | yes |
| fed | | yes |
| ihg | | yes |
| lkj | | yes |
| behkb | roundabout | yes |
When I route I should get
| waypoints | route | turns |
| c,a | cba,cba,cba | depart,roundabout-exit-1,arrive |
| l,a | lkj,cba,cba | depart,roundabout-exit-2,arrive |
| i,a | ihg,cba,cba | depart,roundabout-exit-3,arrive |

1
include/engine/guidance/post_processing.hpp
View File

@ -1,6 +1,7 @@
#ifndef ENGINE_GUIDANCE_POST_PROCESSING_HPP
#define ENGINE_GUIDANCE_POST_PROCESSING_HPP
#include "engine/datafacade/datafacade_base.hpp"
#include "engine/guidance/leg_geometry.hpp"
#include "engine/guidance/route_step.hpp"
#include "engine/phantom_node.hpp"

5
include/extractor/guidance/roundabout_handler.hpp
View File

@ -5,6 +5,7 @@
#include "extractor/guidance/intersection.hpp"
#include "extractor/guidance/intersection_handler.hpp"
#include "extractor/guidance/roundabout_type.hpp"
#include "extractor/profile_properties.hpp"
#include "extractor/query_node.hpp"
#include "util/name_table.hpp"
@ -42,7 +43,8 @@ class RoundaboutHandler : public IntersectionHandler
const std::vector<QueryNode> &node_info_list,
const CompressedEdgeContainer &compressed_edge_container,
const util::NameTable &name_table,
const SuffixTable &street_name_suffix_table);
const SuffixTable &street_name_suffix_table,
const ProfileProperties &profile_properties);
~RoundaboutHandler() override final = default;
@ -81,6 +83,7 @@ class RoundaboutHandler : public IntersectionHandler
bool qualifiesAsRoundaboutIntersection(const std::set<NodeID> &roundabout_nodes) const;
const CompressedEdgeContainer &compressed_edge_container;
const ProfileProperties &profile_properties;
};
} // namespace guidance

3
include/extractor/guidance/turn_analysis.hpp
View File

@ -42,7 +42,8 @@ class TurnAnalysis
const std::unordered_set<NodeID> &barrier_nodes,
const CompressedEdgeContainer &compressed_edge_container,
const util::NameTable &name_table,
const SuffixTable &street_name_suffix_table);
const SuffixTable &street_name_suffix_table,
const ProfileProperties &profile_properties);
// the entry into the turn analysis
Intersection getIntersection(const NodeID from_node, const EdgeID via_eid) const;

3
include/extractor/profile_properties.hpp
View File

@ -12,7 +12,7 @@ struct ProfileProperties
{
ProfileProperties()
: traffic_signal_penalty(0), u_turn_penalty(0), continue_straight_at_waypoint(true),
use_turn_restrictions(false)
use_turn_restrictions(false), left_hand_driving(false)
{
}
@ -36,6 +36,7 @@ struct ProfileProperties
int u_turn_penalty;
bool continue_straight_at_waypoint;
bool use_turn_restrictions;
bool left_hand_driving;
};
}
}

3
profiles/car.lua
View File

@ -138,13 +138,14 @@ properties.u_turn_penalty = 20
properties.traffic_signal_penalty = 2
properties.use_turn_restrictions = true
properties.continue_straight_at_waypoint = true
properties.left_hand_driving = false
local side_road_speed_multiplier = 0.8
local turn_penalty = 10
-- Note: this biases right-side driving. Should be
-- inverted for left-driving countries.
local turn_bias = 1.2
local turn_bias = properties.left_hand_driving and 1/1.2 or 1.2
local obey_oneway = true
local ignore_areas = true

19
profiles/lhs.lua Normal file
View File

@ -0,0 +1,19 @@
-- Testbot, with turn penalty
-- Used for testing turn penalties
require 'testbot'
properties.left_hand_driving = true
local turn_penalty = 500
local turn_bias = properties.left_hand_driving and 1/1.2 or 1.2
function turn_function (angle)
---- compute turn penalty as angle^2, with a left/right bias
k = turn_penalty/(90.0*90.0)
if angle>=0 then
return angle*angle*k/turn_bias
else
return angle*angle*k*turn_bias
end
end

19
profiles/rhs.lua Normal file
View File

@ -0,0 +1,19 @@
-- Testbot, with turn penalty
-- Used for testing turn penalties
require 'testbot'
properties.left_hand_driving = false
local turn_penalty = 500
local turn_bias = properties.left_hand_driving and 1/1.2 or 1.2
function turn_function (angle)
---- compute turn penalty as angle^2, with a left/right bias
k = turn_penalty/(90.0*90.0)
if angle>=0 then
return angle*angle*k/turn_bias
else
return angle*angle*k*turn_bias
end
end

3
src/extractor/edge_based_graph_factory.cpp
View File

@ -342,7 +342,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
m_barrier_nodes,
m_compressed_edge_container,
name_table,
street_name_suffix_table);
street_name_suffix_table,
profile_properties);
guidance::lanes::TurnLaneHandler turn_lane_handler(
*m_node_based_graph, turn_lane_offsets, turn_lane_masks, turn_analysis);

44
src/extractor/guidance/roundabout_handler.cpp
View File

@ -25,9 +25,10 @@ RoundaboutHandler::RoundaboutHandler(const util::NodeBasedDynamicGraph &node_bas
const std::vector<QueryNode> &node_info_list,
const CompressedEdgeContainer &compressed_edge_container,
const util::NameTable &name_table,
const SuffixTable &street_name_suffix_table)
const SuffixTable &street_name_suffix_table,
const ProfileProperties &profile_properties)
: IntersectionHandler(node_based_graph, node_info_list, name_table, street_name_suffix_table),
compressed_edge_container(compressed_edge_container)
compressed_edge_container(compressed_edge_container), profile_properties(profile_properties)
{
}
@ -64,8 +65,13 @@ detail::RoundaboutFlags RoundaboutHandler::getRoundaboutFlags(
bool on_roundabout = in_edge_data.roundabout;
bool can_enter_roundabout = false;
bool can_exit_roundabout_separately = false;
for (const auto &road : intersection)
const bool lhs = profile_properties.left_hand_driving;
const int step = lhs ? -1 : 1;
for (std::size_t cnt = 0, idx = lhs ? intersection.size() - 1 : 0; cnt < intersection.size();
++cnt, idx += step)
{
const auto &road = intersection[idx];
const auto &edge_data = node_based_graph.GetEdgeData(road.turn.eid);
// only check actual outgoing edges
if (edge_data.reversed || !road.entry_allowed)
@ -81,8 +87,6 @@ detail::RoundaboutFlags RoundaboutHandler::getRoundaboutFlags(
// separate vertex than the one we are coming from that are in the direction of
// the roundabout.
// The sorting of the angles represents a problem for left-sided driving, though.
// FIXME in case of left-sided driving, we have to check whether we can enter the
// roundabout later in the cycle, rather than prior.
// FIXME requires consideration of crossing the roundabout
else if (node_based_graph.GetTarget(road.turn.eid) != from_nid && !can_enter_roundabout)
{
@ -101,8 +105,12 @@ void RoundaboutHandler::invalidateExitAgainstDirection(const NodeID from_nid,
return;
bool past_roundabout_angle = false;
for (auto &road : intersection)
const bool lhs = profile_properties.left_hand_driving;
const int step = lhs ? -1 : 1;
for (std::size_t cnt = 0, idx = lhs ? intersection.size() - 1 : 0; cnt < intersection.size();
++cnt, idx += step)
{
auto &road = intersection[idx];
const auto &edge_data = node_based_graph.GetEdgeData(road.turn.eid);
// only check actual outgoing edges
if (edge_data.reversed)
@ -118,8 +126,6 @@ void RoundaboutHandler::invalidateExitAgainstDirection(const NodeID from_nid,
// This workaround handles cases in which an exit precedes and entry. The resulting
// u-turn against the roundabout direction is invalidated.
// The sorting of the angles represents a problem for left-sided driving, though.
// FIXME in case of left-sided driving, we have to check whether we can enter the
// roundabout later in the cycle, rather than prior.
if (!edge_data.roundabout && node_based_graph.GetTarget(road.turn.eid) != from_nid &&
past_roundabout_angle)
{
@ -255,7 +261,7 @@ RoundaboutType RoundaboutHandler::getRoundaboutType(const NodeID nid) const
};
// the roundabout radius has to be the same for all locations we look at it from
// to guarantee this, we search the full roundabout for its vertices
// and select the three smalles ids
// and select the three smallest ids
std::set<NodeID> roundabout_nodes; // needs to be sorted
// this value is a hard abort to deal with potential self-loops
@ -335,9 +341,9 @@ RoundaboutType RoundaboutHandler::getRoundaboutType(const NodeID nid) const
if (radius <= MAX_ROUNDABOUT_INTERSECTION_RADIUS)
{
const bool qualifies_as_roundabout_nitersection =
const bool qualifies_as_roundabout_intersection =
qualifiesAsRoundaboutIntersection(roundabout_nodes);
if (qualifies_as_roundabout_nitersection)
if (qualifies_as_roundabout_intersection)
{
return RoundaboutType::RoundaboutIntersection;
}
@ -357,12 +363,19 @@ Intersection RoundaboutHandler::handleRoundabouts(const RoundaboutType roundabou
{
// detect via radius (get via circle through three vertices)
NodeID node_v = node_based_graph.GetTarget(via_eid);
const bool lhs = profile_properties.left_hand_driving;
const int step = lhs ? -1 : 1;
if (on_roundabout)
{
// Shoule hopefully have only a single exit and continue
// at least for cars. How about bikes?
for (auto &road : intersection)
for (std::size_t cnt = 0, idx = lhs ? intersection.size() - 1 : 0;
cnt < intersection.size();
++cnt, idx += step)
{
auto &road = intersection[idx];
auto &turn = road.turn;
const auto &out_data = node_based_graph.GetEdgeData(road.turn.eid);
if (out_data.roundabout)
@ -395,8 +408,12 @@ Intersection RoundaboutHandler::handleRoundabouts(const RoundaboutType roundabou
return intersection;
}
else
for (auto &road : intersection)
{
for (std::size_t cnt = 0, idx = lhs ? intersection.size() - 1 : 0;
cnt < intersection.size();
++cnt, idx += step)
{
auto &road = intersection[idx];
if (!road.entry_allowed)
continue;
auto &turn = road.turn;
@ -416,6 +433,7 @@ Intersection RoundaboutHandler::handleRoundabouts(const RoundaboutType roundabou
roundabout_type, getTurnDirection(turn.angle));
}
}
}
return intersection;
}

6
src/extractor/guidance/turn_analysis.cpp
View File

@ -37,7 +37,8 @@ TurnAnalysis::TurnAnalysis(const util::NodeBasedDynamicGraph &node_based_graph,
const std::unordered_set<NodeID> &barrier_nodes,
const CompressedEdgeContainer &compressed_edge_container,
const util::NameTable &name_table,
const SuffixTable &street_name_suffix_table)
const SuffixTable &street_name_suffix_table,
const ProfileProperties &profile_properties)
: node_based_graph(node_based_graph), intersection_generator(node_based_graph,
restriction_map,
barrier_nodes,
@ -47,7 +48,8 @@ TurnAnalysis::TurnAnalysis(const util::NodeBasedDynamicGraph &node_based_graph,
node_info_list,
compressed_edge_container,
name_table,
street_name_suffix_table),
street_name_suffix_table,
profile_properties),
motorway_handler(node_based_graph, node_info_list, name_table, street_name_suffix_table),
turn_handler(node_based_graph, node_info_list, name_table, street_name_suffix_table),
sliproad_handler(intersection_generator,

3
src/extractor/scripting_environment_lua.cpp
View File

@ -132,7 +132,8 @@ void LuaScriptingEnvironment::InitContext(LuaScriptingContext &context)
&ProfileProperties::SetUturnPenalty)
.def_readwrite("use_turn_restrictions", &ProfileProperties::use_turn_restrictions)
.def_readwrite("continue_straight_at_waypoint",
&ProfileProperties::continue_straight_at_waypoint),
&ProfileProperties::continue_straight_at_waypoint)
.def_readwrite("left_hand_driving", &ProfileProperties::left_hand_driving),
luabind::class_<std::vector<std::string>>("vector").def(
"Add",