Merge pull request #2707 from oxidase/left_side_driving

Left side driving

CHANGELOG.md

@@ -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:

features/guidance/anticipate-lanes.feature

@@ -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

features/testbot/side_bias.feature

@@ -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 |

include/engine/guidance/post_processing.hpp

@@ -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"

include/extractor/guidance/roundabout_handler.hpp

@@ -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

include/extractor/guidance/turn_analysis.hpp

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

include/extractor/profile_properties.hpp

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

profiles/car.lua

@@ -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

profiles/lhs.lua

@@ -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

profiles/rhs.lua

@@ -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

src/extractor/edge_based_graph_factory.cpp

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

src/extractor/guidance/roundabout_handler.cpp

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

src/extractor/guidance/turn_analysis.cpp

@@ -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,

src/extractor/scripting_environment_lua.cpp

@@ -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",