Prepare for alpha release.

This reverts commit 4686272f87.

Unfortunately, this doesn't work alongside `node-pre-gyp` - in fresh installs, the binary
files are not yet downloaded when npm tries to create symlinks, leading to an error.

.babelrc

@@ -1,4 +1,5 @@
 {
+    "plugins": ["transform-class-properties"],
     "presets": [
         "stage-0",
         "es2015",

.gitignore

@@ -46,6 +46,7 @@ Thumbs.db
 
 # build related files #
 #######################
+/_build*
 /build/
 /example/build/
 /test/data/monaco*

.npmignore

@@ -0,0 +1,15 @@
+*
+!README.md
+!CHANGELOG.md
+!CONTRIBUTING.MD
+!LICENCE.TXT
+!package.json
+!package-lock.json
+!yarn.lock
+!docs
+!example
+!taginfo.json
+!lib/*.js
+!profiles/*
+!profiles/lib/*
+!profiles/examples/*

.travis.yml

@@ -301,7 +301,7 @@ before_install:
   - mkdir -p ${CMAKE_DIR}
   - travis_retry wget --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C ${CMAKE_DIR} || travis_terminate 1
   - export PATH=${CMAKE_DIR}/bin:${PATH}
-  - ${MASON} install tbb 2017_20161128 && export LD_LIBRARY_PATH=$(${MASON} prefix tbb 2017_20161128)/lib/:${LD_LIBRARY_PATH}
+  - ${MASON} install tbb 2017_U7 && export LD_LIBRARY_PATH=$(${MASON} prefix tbb 2017_U7)/lib/:${LD_LIBRARY_PATH}
   - ${MASON} install ccache ${CCACHE_VERSION} && export PATH=$(${MASON} prefix ccache ${CCACHE_VERSION})/bin:${PATH}
   - |
     if [[ ! -z ${CLANG_VERSION} ]]; then

CHANGELOG.md

@@ -1,3 +1,27 @@
+# UNRELEASED
+  - Adds new instruction types at the exit of roundabouts and rotaries `exit roundabout` and `exit rotary`.
+
+# 5.11.0
+  - Changes from 5.10:
+    - Features
+      - BREAKING: Added support for conditional via-way restrictions. This features changes the file format of osrm.restrictions and requires re-extraction
+    - Internals
+      - BREAKING: Traffic signals will no longer be represented as turns internally. This requires re-processing of data but enables via-way turn restrictions across highway=traffic_signals
+      - Additional checks for empty segments when loading traffic data files
+      - Tunes the constants for turns in sharp curves just a tiny bit to circumvent a mix-up in fork directions at a specific intersection (https://github.com/Project-OSRM/osrm-backend/issues/4331)
+    - Infrastructure
+      - Refactor datafacade to make implementing additional DataFacades simpler
+    - Bugfixes
+      - API docs are now buildable again
+      - Suppress unnecessary extra turn instruction when exiting a motorway via a motorway_link onto a primary road (https://github.com/Project-OSRM/osrm-backend/issues/4348 scenario 4)
+      - Suppress unnecessary extra turn instruction when taking a tertiary_link road from a teritary onto a residential road (https://github.com/Project-OSRM/osrm-backend/issues/4348 scenario 2)
+      - Various MSVC++ build environment fixes
+      - Avoid a bug that crashes GCC6
+      - Re-include .npmignore to slim down published modules
+      - Fix a pre-processing bug where incorrect directions could be issued when two turns would have similar instructions and we tried to give them distinct values (https://github.com/Project-OSRM/osrm-backend/pull/4375)
+      - The entry bearing for correct the cardinality of a direction value (https://github.com/Project-OSRM/osrm-backend/pull/4353
+      - Change timezones in West Africa to the WAT zone so they're recognized on the Windows platform
+
 # 5.10.0
   - Changes from 5.9:
     - Profiles:
@@ -17,6 +41,7 @@
       - Guidance: add support for throughabouts
     - Bugfixes
       - Properly save/retrieve datasource annotations for road segments ([#4346](https://github.com/Project-OSRM/osrm-backend/issues/4346)
+      - Fix conditional restriction grammer parsing so it works for single-day-of-week restrictions ([#4357](https://github.com/Project-OSRM/osrm-backend/pull/4357))
     - Algorithm)
       - BREAKING: the file format requires re-processing due to the changes on via-ways
       - Added support for via-way restrictions

CMakeLists.txt

@@ -60,7 +60,7 @@ if (POLICY CMP0048)
 endif()
 project(OSRM C CXX)
 set(OSRM_VERSION_MAJOR 5)
-set(OSRM_VERSION_MINOR 10)
+set(OSRM_VERSION_MINOR 12)
 set(OSRM_VERSION_PATCH 0)
 set(OSRM_VERSION "${OSRM_VERSION_MAJOR}.${OSRM_VERSION_MINOR}.${OSRM_VERSION_PATCH}")
 
@@ -102,11 +102,11 @@ if(WIN32 AND MSVC_VERSION LESS 1900)
 endif()
 
 # Strictly require GCC>=4.9 and Clang>=3.4 - GCC 4.8 is already too old for C++14.
-if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
   if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9)
     message(FATAL_ERROR "GCC>=4.9 required. In case you are on Ubuntu upgrade via ppa:ubuntu-toolchain-r/test")
   endif()
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4)
     message(FATAL_ERROR "Clang>=3.4 required. In case you are on Ubuntu upgrade via http://apt.llvm.org")
   endif()
@@ -182,7 +182,7 @@ endif()
 
 # Disable LTO when mason+gcc is detected before testing for / setting any flags.
 # Mason builds libraries with Clang, mixing does not work in the context of lto.
-if(ENABLE_MASON AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND ENABLE_LTO)
+if(ENABLE_MASON AND CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND ENABLE_LTO)
   set(ENABLE_LTO OFF)
   message(WARNING "Mason and GCC's LTO not work together. Disabling LTO.")
 endif()
@@ -211,9 +211,9 @@ endif()
 if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
   message(STATUS "Configuring debug mode flags")
   set(ENABLE_ASSERTIONS ON)
-  if(NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
+  if(NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-inline -fno-omit-frame-pointer")
-    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
       if (CMAKE_BUILD_TYPE MATCHES Debug)
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Og -ggdb")
       else()
@@ -232,7 +232,7 @@ if(CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CM
   if(ENABLE_LTO AND LTO_AVAILABLE)
     set(OLD_CXX_FLAGS ${CMAKE_CXX_FLAGS})
     # GCC in addition allows parallelizing LTO
-    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
       include(ProcessorCount)
       ProcessorCount(NPROC)
       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto=${NPROC}")
@@ -255,7 +255,7 @@ if(CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CM
     endif()
 
     # Since gcc 4.9 the LTO format is non-standart ('slim'), so we need to use the build-in tools
-    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" AND
+    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND
         NOT "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "4.9.0" AND NOT MINGW)
       find_program(GCC_AR gcc-ar)
       find_program(GCC_RANLIB gcc-ranlib)
@@ -271,7 +271,7 @@ if(CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CM
     endif()
 
     # Same for clang LTO requires their own toolchain
-    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
       find_program(LLVM_AR llvm-ar)
       find_program(LLVM_RANLIB llvm-ranlib)
       if ("${LLVM_AR}" STREQUAL "LLVM_AR-NOTFOUND" OR "${LLVM_RANLIB}" STREQUAL "LLVM_RANLIB-NOTFOUND")
@@ -285,7 +285,7 @@ if(CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CM
       endif()
     endif()
 
-    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" AND "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "4.9.0")
+    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "4.9.0")
       message(STATUS "Disabling LTO on GCC < 4.9.0 since it is broken, see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57038")
       set(CMAKE_CXX_FLAGS "${OLD_CXX_FLAGS}")
       set(ENABLE_LTO Off)
@@ -315,9 +315,9 @@ if (ENABLE_SANITIZER)
 endif()
 
 # Configuring compilers
-if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wuninitialized -Wunreachable-code -Wstrict-overflow=2 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fPIC -fcolor-diagnostics -ftemplate-depth=1024 -Wno-unused-command-line-argument")
-elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
   set(COLOR_FLAG "-fdiagnostics-color=auto")
   check_cxx_compiler_flag("-fdiagnostics-color=auto" HAS_COLOR_FLAG)
   if(NOT HAS_COLOR_FLAG)
@@ -337,13 +337,14 @@ elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fpermissive")
   endif()
 
-elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "Intel")
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
   # using Intel C++
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-intel -wd10237 -Wall -ipo -fPIC")
-elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
   # using Visual Studio C++
   set(BOOST_COMPONENTS ${BOOST_COMPONENTS} zlib)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj") # avoid compiler error C1128 from scripting_environment_lua.cpp
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /DWIN32_LEAN_AND_MEAN") # avoid compiler error C2011 from dual #include of winsock.h and winsock2.h
   add_dependency_defines(-DBOOST_LIB_DIAGNOSTIC)
   add_dependency_defines(-D_CRT_SECURE_NO_WARNINGS)
   add_dependency_defines(-DNOMINMAX) # avoid min and max macros that can break compilation
@@ -359,7 +360,7 @@ execute_process(COMMAND ${CMAKE_CXX_COMPILER} "-Wl,--version" ERROR_QUIET OUTPUT
 # For ld.gold and ld.bfs (the GNU linkers) we optimize hard
 if("${LINKER_VERSION}" MATCHES "GNU gold" OR "${LINKER_VERSION}" MATCHES "GNU ld")
   message(STATUS "Setting linker optimizations")
-  if(NOT (${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC" OR "${LD_AVOID_GC_SECTIONS}"))
+  if(NOT (CMAKE_CXX_COMPILER_ID MATCHES "MSVC" OR "${LD_AVOID_GC_SECTIONS}"))
     # Tell compiler to put every function in separate section, linker can then match sections and functions
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffunction-sections -fdata-sections")
     # Tell linker to do dead code and data eminination during link time discarding sections
@@ -377,7 +378,7 @@ set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
 
 # Activate C++1y
-if(NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
+if(NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++1y")
   set(OSRM_CXXFLAGS "${OSRM_CXXFLAGS} -std=c++1y")
 endif()
@@ -568,7 +569,7 @@ else()
 endif()
 
 # prefix compilation with ccache by default if available and on clang or gcc
-if(ENABLE_CCACHE AND (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU"))
+if(ENABLE_CCACHE AND (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU"))
   find_program(CCACHE_FOUND ccache)
   if(CCACHE_FOUND)
     message(STATUS "Using ccache to speed up incremental builds")

CONTRIBUTING.md

@@ -18,7 +18,7 @@ if [ x"$remote" = xorigin  ] ; then
         echo "Rejected push to $remote/master" ; exit 1
     fi
 
-    ./scripts/format.sh
+    ./scripts/format.sh && ./scripts/error_on_dirty.sh
     if [ $? -ne 0 ] ; then
         echo "Unstaged format changes" ; exit 1
     fi

docs/nodejs/api.md

@@ -27,11 +27,11 @@ var osrm = new OSRM('network.osrm');
                This requires you to run `osrm-datastore` prior to creating an `OSRM` object.
     -   `options.path` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** The path to the `.osrm` files. This is mutually exclusive with setting {options.shared_memory} to true.
     -   `options.max_locations_trip` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in trip query (default: unlimited).
-    -   `options.max_locations_viaroute` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in viaroute query 9default: unlimited).
+    -   `options.max_locations_viaroute` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in viaroute query (default: unlimited).
     -   `options.max_locations_distance_table` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in distance table query (default: unlimited).
-    -   `options.max_locations_map_matching` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in map matching query (default: unlimited).
+    -   `options.max_locations_map_matching` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in map-matching query (default: unlimited).
     -   `options.max_results_nearest` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. results supported in nearest query (default: unlimited).
-    -   `options.max_alternatives` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. number of alternative routes supported (default: 3).
+    -   `options.max_alternatives` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max.number of alternatives supported in alternative routes query (default: 3).
 
 ### route
 
@@ -45,15 +45,16 @@ Returns the fastest route between two or more coordinates while visiting the way
                                           Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
     -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
     -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.alternatives` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Search for alternative routes and return as well.
-        _Please note that even if an alternative route is requested, a result cannot be guaranteed._ (optional, default `false`)
-    -   `options.steps` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Returned route steps for each route leg. (optional, default `false`)
+    -   `options.alternatives` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Search for alternative routes. (optional, default `false`)
+    -   `options.alternatives` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** Search for up to this many alternative routes.
+        _Please note that even if alternative routes are requested, a result cannot be guaranteed._ (optional, default `0`)
+    -   `options.steps` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route steps for each route leg. (optional, default `false`)
     -   `options.annotations` **([Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) \| [Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean))** An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all. (optional, default `false`)
     -   `options.geometries` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
     -   `options.overview` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` according to highest zoom level it could be display on, or not at all (`false`). (optional, default `simplified`)
     -   `options.continue_straight` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Forces the route to keep going straight at waypoints and don't do a uturn even if it would be faster. Default value depends on the profile.
-                         `null`/`true`/`false`
     -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+                         `null`/`true`/`false`
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)** 
 
 **Examples**
@@ -194,14 +195,14 @@ if they can not be matched successfully.
     -   `options.bearings` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
                                           Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
     -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.steps` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Returned route steps for each route. (optional, default `false`)
+    -   `options.steps` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route steps for each route. (optional, default `false`)
     -   `options.annotations` **([Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) \| [Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean))** An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all. (optional, default `false`)
     -   `options.geometries` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
     -   `options.overview` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` according to highest zoom level it could be display on, or not at all (`false`). (optional, default `simplified`)
     -   `options.timestamps` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)<[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)>?** Timestamp of the input location (integers, UNIX-like timestamp).
     -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Standard deviation of GPS precision used for map matching. If applicable use GPS accuracy. Can be `null` for default value `5` meters or `double >= 0`.
-    -   `options.gaps` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Allows the input track splitting based on huge timestamp gaps between points. Either `split` or `ignore`. (optional, default `split`)
-    -   `options.tidy` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Allows the input track modification to obtain better matching quality for noisy tracks. (optional, default `false`)
+    -   `options.gaps` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Allows the input track splitting based on huge timestamp gaps between points. Either `split` or `ignore` (optional, default `split`).
+    -   `options.tidy` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Allows the input track modification to obtain better matching quality for noisy tracks (optional, default `false`).
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)** 
 
 **Examples**
@@ -235,25 +236,7 @@ The trip plugin solves the Traveling Salesman Problem using a greedy heuristic
 waypoints. The returned path does not have to be the shortest path, _ as TSP is NP-hard it is
 only an approximation.
 
-**Parameters**
-
--   `options` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the trip query.
-    -   `options.coordinates` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** The coordinates this request will use, coordinates as `[{lon},{lat}]` values, in decimal degrees.
-    -   `options.bearings` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
-                                          Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
-    -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `double >= 0` or `null` (unlimited, default).
-    -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.steps` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Returned route steps for each route. (optional, default `false`)
-    -   `options.annotations` **([Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) \| [Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean))** An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all. (optional, default `false`)
-    -   `options.geometries` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
-    -   `options.overview` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` (optional, default `simplified`)
-    -   `options.roundtrip` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Returned route is a roundtrip (route returns to first location). (optional, default `true`)
-    -   `options.source` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route starts at `any` or `first` coordinate. (optional, default `any`)
-    -   `options.destination` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route ends at `any` or `last` coordinate. (optional, default `any`)
-    -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)** 
-
-A requirement for computing trips is that all input coordinates are connected.
+Note that all input coordinates have to be connected for the trip service to work.
 Currently, not all combinations of `roundtrip`, `source` and `destination` are supported.
 Right now, the following combinations are possible:
 
@@ -268,6 +251,24 @@ Right now, the following combinations are possible:
 | false     | any    | last        | no        |
 | false     | any    | any         | no        |
 
+**Parameters**
+
+-   `options` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the trip query.
+    -   `options.coordinates` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** The coordinates this request will use, coordinates as `[{lon},{lat}]` values, in decimal degrees.
+    -   `options.bearings` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
+                                          Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
+    -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `double >= 0` or `null` (unlimited, default).
+    -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
+    -   `options.steps` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route steps for each route. (optional, default `false`)
+    -   `options.annotations` **([Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) \| [Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean))** An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all. (optional, default `false`)
+    -   `options.geometries` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
+    -   `options.overview` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` (optional, default `simplified`)
+    -   `options.roundtrip` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route is a roundtrip. (optional, default `true`)
+    -   `options.source` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route starts at `any` or `first` coordinate. (optional, default `any`)
+    -   `options.destination` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route ends at `any` or `last` coordinate. (optional, default `any`)
+    -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+-   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)** 
+
 **Examples**
 
 ```javascript

docs/releasing.md

@@ -47,10 +47,10 @@ We may introduce forward-compatible changes: query parameters and response prope
 4. Make sure the `package.json` is up to date.
 5. Make sure all tests are passing (e.g. Travis CI gives you a :thumbs_up:)
 6. Use an annotated tag to mark the release: `git tag vx.y.z -a` Body of the tag description should be the changelog entries.
-7. Use `npm run build-api-docs` to generate the API documentation.  Copy `build/docs/*` to `https://github.com/Project-OSRM/project-osrm.github.com` in the `docs/vN.N.N/api` directory
+7. Use `npm run docs` to generate the API documentation.  Copy `build/docs/*` to `https://github.com/Project-OSRM/project-osrm.github.com` in the `docs/vN.N.N/api` directory
 8. Push tags and commits: `git push; git push --tags`
 9. If not a release-candidate: Write a mailing-list post to osrm-talk@openstreetmap.org to announce the release
 10. Wait until the travis build has been completed and check if the node binaries were published by doing:
     `rm -rf node_modules && npm install` locally.
 11. For final releases run `npm publish` or `npm publish --tag next` for release candidates.
-
+12. Bump version in `package.json` to `{MAJOR}.{MINOR+1}.0-latest.1` on the `master` branch after the release.

features/bicycle/bridge.feature

@@ -21,13 +21,6 @@ Feature: Bicycle - Handle cycling
         When I route I should get
             | from | to | route           | modes                           |
             | a    | g  | abc,cde,efg,efg | cycling,cycling,cycling,cycling |
-            | b    | f  | abc,cde,efg,efg | cycling,cycling,cycling,cycling |
-            | e    | c  | cde,cde         | cycling,cycling                 |
-            | e    | b  | cde,abc,abc     | cycling,cycling,cycling         |
-            | e    | a  | cde,abc,abc     | cycling,cycling,cycling         |
-            | c    | e  | cde,cde         | cycling,cycling                 |
-            | c    | f  | cde,efg,efg     | cycling,cycling,cycling         |
-            | c    | g  | cde,efg,efg     | cycling,cycling,cycling         |
 
     Scenario: Bicycle - Properly handle durations
         Given the node map

features/bicycle/destination.feature

@@ -21,15 +21,15 @@ Feature: Bike - Destination only, no passing through
             | axye  |             |
 
         When I route I should get
-            | from | to | route      |
-            | a    | b  | ab,ab      |
-            | a    | c  | ab,bcd,bcd |
-            | a    | d  | ab,bcd,bcd |
-            | a    | e  | axye,axye  |
-            | e    | d  | de,de      |
-            | e    | c  | de,bcd,bcd |
-            | e    | b  | de,bcd,bcd |
-            | e    | a  | axye,axye  |
+            | from | to | route     |
+            | a    | b  | ab,ab     |
+            | a    | c  | ab,bcd    |
+            | a    | d  | ab,bcd    |
+            | a    | e  | axye,axye |
+            | e    | d  | de,de     |
+            | e    | c  | de,bcd    |
+            | e    | b  | de,bcd    |
+            | e    | a  | axye,axye |
 
     Scenario: Bike - Destination only street
         Given the node map
@@ -49,15 +49,15 @@ Feature: Bike - Destination only, no passing through
             | axye  |             |
 
         When I route I should get
-            | from | to | route       |
-            | a    | b  | ab,ab       |
-            | a    | c  | ab,bc,bc    |
-            | a    | d  | ab,bc,cd,cd |
-            | a    | e  | axye,axye   |
-            | e    | d  | de,de       |
-            | e    | c  | de,cd,cd    |
-            | e    | b  | de,cd,bc,bc |
-            | e    | a  | axye,axye   |
+            | from | to | route     |
+            | a    | b  | ab,ab     |
+            | a    | c  | ab,bc     |
+            | a    | d  | ab,bc,cd  |
+            | a    | e  | axye,axye |
+            | e    | d  | de,de     |
+            | e    | c  | de,cd,cd  |
+            | e    | b  | de,cd,bc  |
+            | e    | a  | axye,axye |
 
     Scenario: Bike - Routing inside a destination only area
         Given the node map
@@ -76,8 +76,8 @@ Feature: Bike - Destination only, no passing through
             | axye  |             |
 
         When I route I should get
-            | from | to | route          |
-            | a    | e  | ab,bc,cd,de,de |
-            | e    | a  | de,cd,bc,ab,ab |
-            | b    | d  | bc,cd,cd       |
-            | d    | b  | cd,bc,bc       |
+            | from | to | route       |
+            | a    | e  | ab,bc,cd,de |
+            | e    | a  | de,cd,bc,ab |
+            | b    | d  | bc,cd       |
+            | d    | b  | cd,bc       |

features/bicycle/ferry.feature

@@ -21,12 +21,7 @@ Feature: Bike - Handle ferry routes
         When I route I should get
             | from | to | route           |
             | a    | g  | abc,cde,efg,efg |
-            | b    | f  | abc,cde,efg,efg |
-            | e    | c  | cde,cde         |
-            | e    | b  | cde,abc,abc     |
-            | e    | a  | cde,abc,abc     |
             | c    | e  | cde,cde         |
-            | c    | f  | cde,efg,efg     |
             | c    | g  | cde,efg,efg     |
 
     Scenario: Bike - Ferry duration, single node

features/bicycle/mode.feature

@@ -20,11 +20,8 @@ Feature: Bike - Mode flag
     	When I route I should get
     	 | from | to | route       | modes                         |
     	 | a    | d  | ab,bc,cd,cd | cycling,ferry,cycling,cycling |
-    	 | d    | a  | cd,bc,ab,ab | cycling,ferry,cycling,cycling |
     	 | c    | a  | bc,ab,ab    | ferry,cycling,cycling         |
     	 | d    | b  | cd,bc,bc    | cycling,ferry,ferry           |
-    	 | a    | c  | ab,bc,bc    | cycling,ferry,ferry           |
-    	 | b    | d  | bc,cd,cd    | ferry,cycling,cycling         |
 
      Scenario: Bike - Mode when using a train
      	Given the node map
@@ -42,12 +39,10 @@ Feature: Bike - Mode flag
      	When I route I should get
      	 | from | to | route       | modes                         |
      	 | a    | d  | ab,bc,cd,cd | cycling,train,cycling,cycling |
-     	 | d    | a  | cd,bc,ab,ab | cycling,train,cycling,cycling |
      	 | c    | a  | bc,ab,ab    | train,cycling,cycling         |
      	 | d    | b  | cd,bc,bc    | cycling,train,train           |
-     	 | a    | c  | ab,bc,bc    | cycling,train,train           |
-     	 | b    | d  | bc,cd,cd    | train,cycling,cycling         |
 
+     #representative test for all pushes (and mode changes). Where a bike is pushed is tested over in access.feature
      Scenario: Bike - Mode when pushing bike against oneways
      	Given the node map
      	 """
@@ -70,96 +65,6 @@ Feature: Bike - Mode flag
      	 | d    | a  | cd,bc,ab,ab | cycling,pushing bike,cycling,cycling |
      	 | c    | a  | bc,ab,ab    | pushing bike,cycling,cycling         |
      	 | d    | b  | cd,bc,bc    | cycling,pushing bike,pushing bike    |
-     	 | a    | c  | ab,bc,bc    | cycling,cycling,cycling              |
-     	 | b    | d  | bc,cd,cd    | cycling,cycling,cycling              |
-
-     Scenario: Bike - Mode when pushing on pedestrain streets
-     	Given the node map
-     	 """
-     	 a b
-     	   c d
-     	 """
-
-     	And the ways
-     	 | nodes | highway    |
-     	 | ab    | primary    |
-     	 | bc    | pedestrian |
-     	 | cd    | primary    |
-
-     	When I route I should get
-     	 | from | to | route       | modes                                |
-     	 | a    | d  | ab,bc,cd,cd | cycling,pushing bike,cycling,cycling |
-     	 | d    | a  | cd,bc,ab,ab | cycling,pushing bike,cycling,cycling |
-     	 | c    | a  | bc,ab,ab    | pushing bike,cycling,cycling         |
-     	 | d    | b  | cd,bc,bc    | cycling,pushing bike,pushing bike    |
-     	 | a    | c  | ab,bc,bc    | cycling,pushing bike,pushing bike    |
-     	 | b    | d  | bc,cd,cd    | pushing bike,cycling,cycling         |
-
-     Scenario: Bike - Mode when pushing on pedestrain areas
-     	Given the node map
-     	 """
-     	 a b
-     	   c d f
-     	 """
-
-     	And the ways
-     	 | nodes | highway    | area |
-     	 | ab    | primary    |      |
-     	 | bcd   | pedestrian | yes  |
-     	 | df    | primary    |      |
-
-     	When I route I should get
-     	 | from | to | route        | modes                                |
-     	 | a    | f  | ab,bcd,df,df | cycling,pushing bike,cycling,cycling |
-     	 | f    | a  | df,bcd,ab,ab | cycling,pushing bike,cycling,cycling |
-     	 | d    | a  | bcd,ab,ab    | pushing bike,cycling,cycling         |
-     	 | f    | b  | df,bcd,bcd   | cycling,pushing bike,pushing bike    |
-     	 | a    | d  | ab,bcd,bcd   | cycling,pushing bike,pushing bike    |
-     	 | b    | f  | bcd,df,df    | pushing bike,cycling,cycling         |
-
-     Scenario: Bike - Mode when pushing on steps
-     	Given the node map
-     	 """
-     	 a b
-     	   c d f
-     	 """
-
-     	And the ways
-    	 | nodes | highway |
-    	 | ab    | primary |
-    	 | bc    | steps   |
-    	 | cd    | primary |
-
-     	When I route I should get
-    	 | from | to | route       | modes                                |
-    	 | a    | d  | ab,bc,cd,cd | cycling,pushing bike,cycling,cycling |
-    	 | d    | a  | cd,bc,ab,ab | cycling,pushing bike,cycling,cycling |
-    	 | c    | a  | bc,ab,ab    | pushing bike,cycling,cycling         |
-    	 | d    | b  | cd,bc,bc    | cycling,pushing bike,pushing bike    |
-    	 | a    | c  | ab,bc,bc    | cycling,pushing bike,pushing bike    |
-    	 | b    | d  | bc,cd,cd    | pushing bike,cycling,cycling         |
-
-     Scenario: Bike - Mode when bicycle=dismount
-     	Given the node map
-     	 """
-     	 a b
-     	   c d f
-     	 """
-
-     	And the ways
-    	 | nodes | highway | bicycle  |
-    	 | ab    | primary |          |
-    	 | bc    | primary | dismount |
-    	 | cd    | primary |          |
-
-     	When I route I should get
-    	 | from | to | route       | modes                                |
-    	 | a    | d  | ab,bc,cd,cd | cycling,pushing bike,cycling,cycling |
-    	 | d    | a  | cd,bc,ab,ab | cycling,pushing bike,cycling,cycling |
-    	 | c    | a  | bc,ab,ab    | pushing bike,cycling,cycling         |
-    	 | d    | b  | cd,bc,bc    | cycling,pushing bike,pushing bike    |
-    	 | a    | c  | ab,bc,bc    | cycling,pushing bike,pushing bike    |
-         | b    | d  | bc,cd,cd  | pushing bike,cycling,cycling         |
 
     Scenario: Bicycle - Modes when starting on forward oneway
         Given the node map

features/bicycle/ref.feature

@@ -1,47 +0,0 @@
-@routing @bicycle @ref @name
-Feature: Bike - Way ref
-
-    Background:
-        Given the profile "bicycle"
-
-    Scenario: Bike - Way with both name and ref
-        Given the node map
-            """
-            a b
-            """
-
-        And the ways
-            | nodes | name         | ref |
-            | ab    | Utopia Drive | E7  |
-
-        When I route I should get
-            | from | to | route                               | ref   |
-            | a    | b  | Utopia Drive,Utopia Drive           | E7,E7 |
-
-    Scenario: Bike - Way with only ref
-        Given the node map
-            """
-            a b
-            """
-
-        And the ways
-            | nodes | name | ref |
-            | ab    |      | E7  |
-
-        When I route I should get
-            | from | to | route | ref   |
-            | a    | b  | ,     | E7,E7 |
-
-    Scenario: Bike - Way with only name
-        Given the node map
-            """
-            a b
-            """
-
-        And the ways
-            | nodes | name         |
-            | ab    | Utopia Drive |
-
-        When I route I should get
-            | from | to | route                     |
-            | a    | b  | Utopia Drive,Utopia Drive |

features/bicycle/restrictions.feature

@@ -7,6 +7,8 @@ Feature: Bike - Turn restrictions
         Given the profile "bicycle"
         Given a grid size of 200 meters
 
+    # check to see if bicycle profiles handle relations. The code path is the same as in cars.
+    # If relations are passed, all variants tested in car also work for bike
     @no_turning
     Scenario: Bike - No left turn
         Given the node map
@@ -33,188 +35,7 @@ Feature: Bike - Turn restrictions
             | s    | n  | sj,nj,nj |
             | s    | e  | sj,ej,ej |
 
-    @no_turning
-    Scenario: Bike - No right turn
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway | foot |
-            | sj    | yes    | no   |
-            | nj    | -1     | no   |
-            | wj    | -1     | no   |
-            | ej    | -1     | no   |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction   |
-            | restriction | sj       | ej     | j        | no_right_turn |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
-    @no_turning
-    Scenario: Bike - No u-turn
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway | foot |
-            | sj    | yes    | no   |
-            | nj    | -1     | no   |
-            | wj    | -1     | no   |
-            | ej    | -1     | no   |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction |
-            | restriction | sj       | wj     | j        | no_u_turn   |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
-    @no_turning
-    Scenario: Bike - Handle any no_* relation
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway | foot |
-            | sj    | yes    | no   |
-            | nj    | -1     | no   |
-            | wj    | -1     | no   |
-            | ej    | -1     | no   |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction      |
-            | restriction | sj       | wj     | j        | no_weird_zigzags |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
-    @only_turning
-    Scenario: Bike - Only left turn
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway | foot |
-            | sj    | yes    | no   |
-            | nj    | -1     | no   |
-            | wj    | -1     | no   |
-            | ej    | -1     | no   |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction    |
-            | restriction | sj       | wj     | j        | only_left_turn |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
-    @only_turning
-    Scenario: Bike - Only right turn
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway | foot |
-            | sj    | yes    | no   |
-            | nj    | -1     | no   |
-            | wj    | -1     | no   |
-            | ej    | -1     | no   |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction     |
-            | restriction | sj       | ej     | j        | only_right_turn |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
-    @only_turning
-    Scenario: Bike - Only straight on
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway | foot |
-            | sj    | yes    | no   |
-            | nj    | -1     | no   |
-            | wj    | -1     | no   |
-            | ej    | -1     | no   |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction      |
-            | restriction | sj       | nj     | j        | only_straight_on |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
-    @no_turning
-    Scenario: Bike - Handle any only_* restriction
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway | foot |
-            | sj    | yes    | no   |
-            | nj    | -1     | no   |
-            | wj    | -1     | no   |
-            | ej    | -1     | no   |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction        |
-            | restriction | sj       | nj     | j        | only_weird_zigzags |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
+    ## exceptions are different for bike over car and need to be tested here
     @except
     Scenario: Bike - Except tag and on no_ restrictions
         Given the node map

features/car/bridge.feature

@@ -22,13 +22,7 @@ Feature: Car - Handle driving
         When I route I should get
             | from | to | route           | modes                           |
             | a    | g  | abc,cde,efg,efg | driving,driving,driving,driving |
-            | b    | f  | abc,cde,efg,efg | driving,driving,driving,driving |
-            | e    | c  | cde,cde         | driving,driving                 |
-            | e    | b  | cde,abc,abc     | driving,driving,driving         |
             | e    | a  | cde,abc,abc     | driving,driving,driving         |
-            | c    | e  | cde,cde         | driving,driving                 |
-            | c    | f  | cde,efg,efg     | driving,driving,driving         |
-            | c    | g  | cde,efg,efg     | driving,driving,driving         |
 
     Scenario: Car - Control test without durations, osrm uses movable bridge speed to calculate duration
         Given the node map
@@ -47,8 +41,6 @@ Feature: Car - Handle driving
         When I route I should get
             | from | to | route           | modes                           | speed   | time     |
             | a    | g  | abc,cde,efg,efg | driving,driving,driving,driving | 13 km/h | 340s +-1 |
-            | b    | f  | abc,cde,efg,efg | driving,driving,driving,driving | 9 km/h  | 318s +-1 |
-            | c    | e  | cde,cde         | driving,driving                 | 5 km/h  | 295s +-1 |
             | e    | c  | cde,cde         | driving,driving                 | 5 km/h  | 295s +-1 |
 
     Scenario: Car - Properly handle durations
@@ -68,6 +60,5 @@ Feature: Car - Handle driving
         When I route I should get
             | from | to | route           | modes                           | speed  |
             | a    | g  | abc,cde,efg,efg | driving,driving,driving,driving | 7 km/h |
-            | b    | f  | abc,cde,efg,efg | driving,driving,driving,driving | 5 km/h |
             | c    | e  | cde,cde         | driving,driving                 | 2 km/h |
             | e    | c  | cde,cde         | driving,driving                 | 2 km/h |

features/car/classes.feature

@@ -122,6 +122,6 @@ Feature: Car - Mode flag
             | df    | yes    | motorway|            | yes      |
 
         When I route I should get
-            | from | to | route    | turns                           | classes                                   |
-            | a    | f  | ab,df,df | depart,roundabout-exit-2,arrive | [()],[(),(motorway),(toll,motorway)],[()] |
+            | from | to | route       | turns                                                        | classes                                     |
+            | a    | f  | ab,df,df,df | depart,roundabout-exit-2,exit roundabout slight right,arrive | [()],[(),(motorway)],[(toll,motorway)],[()] |
 

features/car/conditional_restrictions.feature

@@ -72,6 +72,75 @@ Feature: Car - Turn restrictions
             | n    | m  | nj,pjm,pjm |
             | s    | m  | js,pjm,pjm |
 
+    @no_turning @conditionals
+    Scenario: Car - Restriction With Compressed Geometry
+        Given the extract extra arguments "--parse-conditional-restrictions"
+                                            # time stamp for 10am on Tues, 02 May 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+
+        Given the node map
+            """
+            n
+            |
+            i
+            |
+            j-k-l-m
+            |
+            s
+            """
+
+        And the ways
+            | nodes |
+            | nij   |
+            | js    |
+            | jklm  |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction:conditional             |
+            | restriction | nij      | jklm   | j        | no_left_turn @ (Mo-Fr 07:00-10:30)  |
+
+        When I route I should get
+            | from | to | route               |
+            | n    | m  | nij,js,js,jklm,jklm |
+
+    @no_turning @conditionals
+    Scenario: Car - Restriction With Compressed Geometry and Traffic Signal
+        Given the extract extra arguments "--parse-conditional-restrictions"
+                                            # time stamp for 10am on Tues, 02 May 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+
+        Given the node map
+            """
+            n
+            |
+            i
+            |
+            j-k-l-m
+            |
+            s
+            """
+
+        And the ways
+            | nodes |
+            | nij   |
+            | js    |
+            | jklm  |
+
+        And the nodes
+            | node | highway        |
+            | i    | traffic_signal |
+            | k    | traffic_signal |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction:conditional             |
+            | restriction | nij      | jklm   | j        | no_left_turn @ (Mo-Fr 07:00-10:30)  |
+
+        When I route I should get
+            | from | to | route               |
+            | n    | m  | nij,js,js,jklm,jklm |
+
     @no_turning @conditionals
     Scenario: Car - ignores except restriction
         Given the extract extra arguments "--parse-conditional-restrictions"
@@ -530,6 +599,81 @@ Feature: Car - Turn restrictions
             | n    | p  | nj,js,js,jp,jp |
             | m    | p  | mj,jp,jp       |
 
+    @restriction-way
+    Scenario: Car - prohibit turn
+        Given the extract extra arguments "--parse-conditional-restrictions"
+        # 5pm Wed 02 May, 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
+
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b---e
+            |   |
+            a   d
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | be    |
+            | de    |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction:conditional                         |
+            | restriction | ab       | be      | de     | no_right_turn @ (Mo-Fr 07:00-11:00,16:00-18:30) |
+
+        When I route I should get
+            | from | to | route             | turns                                                               | locations   |
+            | a    | d  | ab,be,ef,ef,de,de | depart,turn right,turn left,continue uturn,new name straight,arrive | a,b,e,f,e,d |
+            | a    | f  | ab,be,ef,ef       | depart,turn right,turn left,arrive                                  | a,b,e,f     |
+            | c    | d  | bc,be,de,de       | depart,turn left,turn right,arrive                                  | c,b,e,d     |
+            | c    | f  | bc,be,ef,ef       | depart,turn left,turn left,arrive                                   | c,b,e,f     |
+
+    # condition is off
+    @restriction-way
+    Scenario: Car - prohibit turn
+        Given the extract extra arguments "--parse-conditional-restrictions"
+        # time stamp for 12am on Tues, 02 May 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493726400"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493726400"
+
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b---e
+            |   |
+            a   d
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | be    |
+            | de    |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction:conditional                         |
+            | restriction | ab       | be      | de     | no_right_turn @ (Mo-Fr 07:00-11:00,16:00-18:30) |
+
+        When I route I should get
+            | from | to | route       |
+            | a    | d  | ab,be,de,de |
+            | a    | f  | ab,be,ef,ef |
+            | c    | d  | bc,be,de,de |
+            | c    | f  | bc,be,ef,ef |
+
     # https://www.openstreetmap.org/#map=18/38.91099/-77.00888
     @no_turning @conditionals
     Scenario: Car - DC North capitol situation, two on one off
@@ -739,3 +883,175 @@ Feature: Car - Turn restrictions
             | from | to | route                       | turns                                            |
             | a    | c  | albic,dobe,dobe,albic,albic | depart,turn left,continue uturn,turn left,arrive |
             | a    | e  | albic,dobe,dobe             | depart,turn left,arrive                          |
+
+    @no_turning @conditionals
+    Scenario: Car - Conditional restriction with multiple time windows
+        Given the extract extra arguments "--parse-conditional-restrictions"
+        # 5pm Wed 02 May, 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
+
+        Given the node map
+            """
+            a   f
+            |   |
+            b - e - h
+            |   |   |
+            c   d - g
+                  1
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | de    |
+            | ef    |
+            | be    |
+            | eh    |
+            | gh    |
+            | dg    |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction:conditional                    |
+            | restriction | ab       | be      | ef     | no_uturn @ (Mo-Fr 07:00-11:00,16:00-18:30) |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction:conditional                    |
+            | restriction | ed       | dg     | d        | no_uturn @ (Mo-Fr 07:00-11:00,16:00-18:30) |
+
+        When I route I should get
+            | from | to | route             |
+            | a    | f  | ab,bc,bc,be,ef,ef |
+            | f    | 1  | ef,eh,gh,dg,dg    |
+
+    @restriction-way @overlap
+    Scenario: Car - prohibit turn
+        Given the extract extra arguments "--parse-conditional-restrictions"
+        # 5pm Wed 02 May, 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
+
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b---e
+            |   |
+            a   d
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | be    |
+            | de    |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction:conditional             |
+            | restriction | ab       | be      | de     | no_right_turn @ (Mo-Fr 07:00-11:00) |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction   |
+            | restriction | ab       | be      | de     | no_right_turn |
+
+        # condition is off, but the general restriction should take precedence
+        When I route I should get
+            | from | to | route             | turns                                                               | locations   |
+            | a    | d  | ab,be,ef,ef,de,de | depart,turn right,turn left,continue uturn,new name straight,arrive | a,b,e,f,e,d |
+            | a    | f  | ab,be,ef,ef       | depart,turn right,turn left,arrive                                  | a,b,e,f     |
+            | c    | d  | bc,be,de,de       | depart,turn left,turn right,arrive                                  | c,b,e,d     |
+            | c    | f  | bc,be,ef,ef       | depart,turn left,turn left,arrive                                   | c,b,e,f     |
+
+    @restriction-way @overlap
+    Scenario: Car - prohibit turn
+        Given the extract extra arguments "--parse-conditional-restrictions"
+        # 5pm Wed 02 May, 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
+
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b---e
+            |   |
+            |   d
+            |
+            a
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | be    |
+            | de    |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction:conditional             |
+            | restriction | ab       | be      | de     | no_right_turn @ (Mo-Fr 07:00-11:00) |
+
+        And the relations
+            | type        | way:from | node:via | way:to | restriction:conditional             |
+            | restriction | be       | e        | de     | no_right_turn @ (Mo-Fr 16:00-18:00) |
+
+        # way restriction is off, node-restriction is on
+        When I route I should get
+            | from | to | route             | turns                                                               | locations   |
+            | a    | d  | ab,be,ef,ef,de,de | depart,turn right,turn left,continue uturn,new name straight,arrive | a,b,e,f,e,d |
+            | a    | f  | ab,be,ef,ef       | depart,turn right,turn left,arrive                                  | a,b,e,f     |
+            | c    | d  | bc,be,ef,ef,de,de | depart,turn left,turn left,continue uturn,new name straight,arrive  | c,b,e,f,e,d |
+            | c    | f  | bc,be,ef,ef       | depart,turn left,turn left,arrive                                   | c,b,e,f     |
+
+    @restriction-way @overlap
+    Scenario: Car - prohibit turn
+        Given the extract extra arguments "--parse-conditional-restrictions"
+        # 5pm Wed 02 May, 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
+
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b---e
+            |   |
+            |   d
+            |
+            a
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | be    |
+            | de    |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction:conditional             |
+            | restriction | ab       | be      | de     | no_right_turn @ (Mo-Fr 16:00-18:00) |
+
+        And the relations
+            | type        | way:from | node:via | way:to | restriction:conditional             |
+            | restriction | be       | e        | de     | no_right_turn @ (Mo-Fr 07:00-11:00) |
+
+        # node restrictino is off, way restriction is on
+        When I route I should get
+            | from | to | route             | turns                                                               | locations   |
+            | a    | d  | ab,be,ef,ef,de,de | depart,turn right,turn left,continue uturn,new name straight,arrive | a,b,e,f,e,d |
+            | a    | f  | ab,be,ef,ef       | depart,turn right,turn left,arrive                                  | a,b,e,f     |
+            | c    | d  | bc,be,de,de       | depart,turn left,turn right,arrive                                  | c,b,e,d     |
+            | c    | f  | bc,be,ef,ef       | depart,turn left,turn left,arrive                                   | c,b,e,f     |
+

features/car/ferry.feature

@@ -50,6 +50,7 @@ Feature: Car - Handle ferry routes
             | b    | f  | abc,cde,efg,efg | driving,ferry,driving,driving | 9 km/h  | 162.4s  |
             | c    | e  | cde,cde         | ferry,ferry                   | 5 km/h  | 151.4s  |
             | e    | c  | cde,cde         | ferry,ferry                   | 5 km/h  | 151.4s  |
+
     Scenario: Car - Properly handle simple durations
         Given the node map
             """
@@ -91,3 +92,20 @@ Feature: Car - Handle ferry routes
             | b    | f  | abc,cde,efg,efg | driving,ferry,driving,driving | 18 km/h | 78.4s |
             | c    | e  | cde,cde         | ferry,ferry                   | 11 km/h | 67.4s |
             | e    | c  | cde,cde         | ferry,ferry                   | 11 km/h | 67.4s |
+
+	@snapping
+    Scenario: Car - Snapping when using a ferry
+        Given the node map
+            """
+            a b   c d   e f
+            """
+
+        And the ways
+            | nodes | highway | route | duration |
+            | ab    | primary |       |          |
+            | bcde  |         | ferry | 0:10     |
+            | ef    | primary |       |          |
+
+        When I route I should get
+            | from | to | route     | modes       | time  |
+            | c    | d  | bcde,bcde | ferry,ferry | 600s  |

features/car/mode.feature

@@ -1,44 +0,0 @@
-@routing @car @mode
-Feature: Car - Mode flag
-    Background:
-        Given the profile "car"
-
-    Scenario: Car - Mode when using a ferry
-        Given the node map
-            """
-            a b
-              c d
-            """
-
-        And the ways
-            | nodes | highway | route | duration |
-            | ab    | primary |       |          |
-            | bc    |         | ferry | 0:01     |
-            | cd    | primary |       |          |
-
-        When I route I should get
-            | from | to | route       | modes                         |
-            | a    | d  | ab,bc,cd,cd | driving,ferry,driving,driving |
-            | d    | a  | cd,bc,ab,ab | driving,ferry,driving,driving |
-            | c    | a  | bc,ab,ab    | ferry,driving,driving         |
-            | d    | b  | cd,bc,bc    | driving,ferry,ferry           |
-            | a    | c  | ab,bc,bc    | driving,ferry,ferry           |
-            | b    | d  | bc,cd,cd    | ferry,driving,driving         |
-
-    Scenario: Car - Snapping when using a ferry
-        Given the node map
-            """
-            a b   c d   e f
-            """
-
-        And the ways
-            | nodes | highway | route | duration |
-            | ab    | primary |       |          |
-            | bcde  |         | ferry | 0:10     |
-            | ef    | primary |       |          |
-
-        When I route I should get
-            | from | to | route     | modes       | time  |
-            | c    | d  | bcde,bcde | ferry,ferry | 600s  |
-
-

features/car/names.feature

@@ -5,22 +5,6 @@ Feature: Car - Street names in instructions
         Given the profile "car"
         Given a grid size of 5 meters
 
-    Scenario: Car - A named street
-        Given the node map
-            """
-            a b
-              c
-            """
-
-        And the ways
-            | nodes | name     | ref |
-            | ab    | My Way   |     |
-            | bc    | Your Way | A1  |
-
-        When I route I should get
-            | from | to | route           | ref  |
-            | a    | c  | My Way,Your Way | ,A1|
-
     Scenario: Car - A named street with pronunciation
         Given the node map
             """

features/car/restrictions.feature

@@ -954,11 +954,11 @@ Feature: Car - Turn restrictions
         # this case is currently not handling the via-way restrictions and we need support for looking across traffic signals.
         # It is mainly included to show limitations and to prove that we don't crash hard here
         When I route I should get
-            | from | to | route        |
-            | a    | d  | ab,bge,de,de |
-            | a    | f  | ab,bge,ef,ef |
-            | c    | d  | bc,bge,de,de |
-            | c    | f  | bc,bge,ef,ef |
+            | from | to | route              |
+            | a    | d  | ab,bge,ef,ef,de,de |
+            | a    | f  | ab,bge,ef,ef       |
+            | c    | d  | bc,bge,de,de       |
+            | c    | f  | bc,bge,de,de,ef,ef |
 
       # don't crash hard on invalid restrictions
       @restriction @invalid
@@ -991,3 +991,40 @@ Feature: Car - Turn restrictions
         When I route I should get
             | from | to | route       |
             | a    | f  | ab,be,ef,ef |
+
+
+    @restriction @overlap @geometry
+    Scenario: Duplicated restriction
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b-g-e
+            |   |
+            |   d
+            |
+            a
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | bge   |
+            | de    |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction  |
+            | restriction | bge      | ef     | e        | no_left_turn |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction   |
+            | restriction | ab       | bge     | de     | no_right_turn |
+            | restriction | bc       | bge     | ef     | no_left_turn  |
+
+        When I route I should get
+            | from | to | route              |
+            | a    | d  | ab,bc,bc,bge,de,de |

features/car/side_bias.feature

@@ -47,32 +47,3 @@ Feature: Testbot - side bias
             | d    | a  | bd,ab,ab | 27s +-1    |
                                             # should be inverse of left hand bias
             | d    | c  | bd,bc,bc | 24s +-1    |
-
-    Scenario: Roundabout exit counting for left sided driving
-        Given the profile file "testbot" initialized with
-        """
-        profile.left_hand_driving = true
-        profile.turn_bias = 1/1.075
-        """
-        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 turn left exit-1,arrive     |
-           | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive |
-           | a,h       | ab,gh,gh | depart,roundabout turn right exit-3,arrive    |

features/car/traffic_light_penalties.feature

@@ -37,3 +37,57 @@ Feature: Car - Handle traffic lights
             | 3    | 4  |  13.1s | no turn with traffic light    |
             | g    | j  |  18.7s | turn with no traffic light    |
             | k    | n  |  20.7s | turn with traffic light       |
+
+
+    Scenario: Tarrif Signal Geometry
+        Given the query options
+            | overview   | full      |
+            | geometries | polyline  |
+
+        Given the node map
+            """
+            a - b - c
+            """
+
+        And the ways
+            | nodes | highway |
+            | abc   | primary |
+
+        And the nodes
+            | node | highway         |
+            | b    | traffic_signals |
+
+        When I route I should get
+            | from | to | route   | geometry       |
+            | a    | c  | abc,abc | _ibE_ibE?gJ?gJ |
+
+    @traffic
+    Scenario: Traffic update on the edge with a traffic signal
+        Given the node map
+            """
+            a - b - c
+            """
+
+        And the ways
+          | nodes | highway |
+          | abc   | primary |
+
+
+        And the nodes
+            | node | highway         |
+            | b    | traffic_signals |
+
+        And the contract extra arguments "--segment-speed-file {speeds_file}"
+        And the customize extra arguments "--segment-speed-file {speeds_file}"
+        And the speed file
+        """
+        1,2,65
+        2,1,65
+        """
+        And the query options
+          | annotations | datasources,nodes,speed,duration,weight |
+
+        When I route I should get
+          | from | to | route   | speed   | weights | time  | distances | a:datasources | a:nodes | a:speed | a:duration |  a:weight |
+          | a    | c  | abc,abc | 59 km/h | 24.2,0  | 24.2s | 399.9m,0m |           1:0 |  1:2:3  |   18:18 |  11.1:11.1 | 11.1:11.1 |
+          | c    | a  | abc,abc | 59 km/h | 24.2,0  | 24.2s | 399.9m,0m |           0:1 |  3:2:1  |   18:18 |  11.1:11.1 | 11.1:11.1 |

features/foot/ferry.feature

@@ -21,13 +21,7 @@ Feature: Foot - Handle ferry routes
         When I route I should get
             | from | to | route           | modes                         |
             | a    | g  | abc,cde,efg,efg | walking,ferry,walking,walking |
-            | b    | f  | abc,cde,efg,efg | walking,ferry,walking,walking |
-            | e    | c  | cde,cde         | ferry,ferry                   |
-            | e    | b  | cde,abc,abc     | ferry,walking,walking         |
             | e    | a  | cde,abc,abc     | ferry,walking,walking         |
-            | c    | e  | cde,cde         | ferry,ferry                   |
-            | c    | f  | cde,efg,efg     | ferry,walking,walking         |
-            | c    | g  | cde,efg,efg     | ferry,walking,walking         |
 
     Scenario: Foot - Ferry duration, single node
         Given the node map

features/foot/names.feature

@@ -14,25 +14,9 @@ Feature: Foot - Street names in instructions
 
         And the ways
             | nodes | name     | ref |
-            | ab    | My Way   | A6  |
-            | bc    | Your Way | B7  |
+            | ab    | My Way   |     |
+            | bc    |          | A7  |
 
         When I route I should get
-            | from | to | route                                   |
-            | a    | c  | My Way,Your Way,Your Way                |
-
-    @unnamed
-    Scenario: Foot - No longer use way type to describe unnamed ways, see #3231
-        Given the node map
-            """
-            a b c d
-            """
-
-        And the ways
-            | nodes | highway | name |
-            | ab    | footway |      |
-            | bcd   | track   |      |
-
-        When I route I should get
-            | from | to | route |
-            | a    | d  | ,     |
+            | from | to | route    | ref    |
+            | a    | c  | My Way,, | ,A7,A7 |

features/foot/ref.feature

@@ -1,47 +0,0 @@
-@routing @foot @ref @name
-Feature: Foot - Way ref
-
-    Background:
-        Given the profile "foot"
-
-    Scenario: Foot - Way with both name and ref
-        Given the node map
-            """
-            a b
-            """
-
-        And the ways
-            | nodes | name         | ref |
-            | ab    | Utopia Drive | E7  |
-
-        When I route I should get
-            | from | to | route                     | ref   |
-            | a    | b  | Utopia Drive,Utopia Drive | E7,E7 |
-
-    Scenario: Foot - Way with only ref
-        Given the node map
-            """
-            a b
-            """
-
-        And the ways
-            | nodes | name | ref |
-            | ab    |      | E7  |
-
-        When I route I should get
-            | from | to | route | ref   |
-            | a    | b  | ,     | E7,E7 |
-
-    Scenario: Foot - Way with only name
-        Given the node map
-            """
-            a b
-            """
-
-        And the ways
-            | nodes | name         |
-            | ab    | Utopia Drive |
-
-        When I route I should get
-            | from | to | route                     |
-            | a    | b  | Utopia Drive,Utopia Drive |

features/foot/restrictions.feature

@@ -32,84 +32,6 @@ Feature: Foot - Turn restrictions
             | s    | n  | sj,nj,nj |
             | s    | e  | sj,ej,ej |
 
-    @no_turning
-    Scenario: Foot - No right turn
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway |
-            | sj    | yes    |
-            | nj    | -1     |
-            | wj    | -1     |
-            | ej    | -1     |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction   |
-            | restriction | sj       | ej     | j        | no_right_turn |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
-    @no_turning
-    Scenario: Foot - No u-turn
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway |
-            | sj    | yes    |
-            | nj    | -1     |
-            | wj    | -1     |
-            | ej    | -1     |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction |
-            | restriction | sj       | wj     | j        | no_u_turn   |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
-    @no_turning
-    Scenario: Foot - Handle any no_* relation
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway |
-            | sj    | yes    |
-            | nj    | -1     |
-            | wj    | -1     |
-            | ej    | -1     |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction      |
-            | restriction | sj       | wj     | j        | no_weird_zigzags |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
     @only_turning
     Scenario: Foot - Only left turn
         Given the node map
@@ -136,84 +58,6 @@ Feature: Foot - Turn restrictions
             | s    | n  | sj,nj,nj |
             | s    | e  | sj,ej,ej |
 
-    @only_turning
-    Scenario: Foot - Only right turn
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway |
-            | sj    | yes    |
-            | nj    | -1     |
-            | wj    | -1     |
-            | ej    | -1     |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction     |
-            | restriction | sj       | ej     | j        | only_right_turn |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
-    @only_turning
-    Scenario: Foot - Only straight on
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway |
-            | sj    | yes    |
-            | nj    | -1     |
-            | wj    | -1     |
-            | ej    | -1     |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction      |
-            | restriction | sj       | nj     | j        | only_straight_on |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
-    @no_turning
-    Scenario: Foot - Handle any only_* restriction
-        Given the node map
-            """
-              n
-            w j e
-              s
-            """
-
-        And the ways
-            | nodes | oneway |
-            | sj    | yes    |
-            | nj    | -1     |
-            | wj    | -1     |
-            | ej    | -1     |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction        |
-            | restriction | sj       | nj     | j        | only_weird_zigzags |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
-            | s    | e  | sj,ej,ej |
-
     @except
     Scenario: Foot - Except tag and on no_ restrictions
         Given the node map
@@ -246,30 +90,6 @@ Feature: Foot - Turn restrictions
             | s    | c  | sj,cj,cj |
             | s    | d  | sj,dj,dj |
 
-    @except
-    Scenario: Foot - Except tag and on only_ restrictions
-        Given the node map
-            """
-            a   b
-              j
-              s
-            """
-
-        And the ways
-            | nodes | oneway |
-            | sj    | yes    |
-            | aj    | no     |
-            | bj    | no     |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction      | except |
-            | restriction | sj       | aj     | j        | only_straight_on | foot   |
-
-        When I route I should get
-            | from | to | route    |
-            | s    | a  | sj,aj,aj |
-            | s    | b  | sj,bj,bj |
-
     @except
     Scenario: Foot - Multiple except tag values
         Given the node map

features/foot/roundabout.feature

@@ -1,10 +1,9 @@
-@routing @foot @roundabout @instruction
+@routing @foot @roundabout @instruction @todo
 Feature: Roundabout Instructions
 
     Background:
         Given the profile "foot"
 
-    @todo
     Scenario: Foot - Roundabout instructions
     # You can walk in both directions on a roundabout, bu the normal roundabout instructions don't
     # make sense when you're going the opposite way around the roundabout.
@@ -27,7 +26,7 @@ Feature: Roundabout Instructions
             | abcda | roundabout |
 
         When I route I should get
-            | from | to | route | turns                            |
+            | from | to | route | turns                           |
             | s    | t  | sa,tb | depart,roundabout-exit-1,arrive |
             | s    | u  | sa,uc | depart,roundabout-exit-2,arrive |
             | s    | v  | sa,vd | depart,roundabout-exit-3,arrive |

features/guidance/anticipate-lanes.feature

@@ -52,9 +52,9 @@ Feature: Turn Lane Guidance
             | dy    |                       |                     | YSt  |
 
        When I route I should get
-            | waypoints | route               | turns                                   | lanes                                                         |
-            | a,e       | MySt,MySt,MySt,MySt | depart,continue right,turn right,arrive | ,straight:false right:false right:true,left:false right:true, |
-            | e,a       | MySt,MySt,MySt,MySt | depart,continue left,turn left,arrive   | ,left:true left:false straight:false,left:true right:false,   |
+            | waypoints | route               | turns                                       | lanes                                                         |
+            | a,e       | MySt,MySt,MySt,MySt | depart,continue right,continue right,arrive | ,straight:false right:false right:true,left:false right:true, |
+            | e,a       | MySt,MySt,MySt,MySt | depart,continue left,continue left,arrive   | ,left:true left:false straight:false,left:true right:false,   |
 
     @anticipate
     Scenario: Anticipate Lane Change for quick same direction turns, changing between streets
@@ -553,8 +553,8 @@ Feature: Turn Lane Guidance
             | fy    |                            | primary |            |
 
         When I route I should get
-            | waypoints | route    | turns                           | lanes    |
-            | a,h       | ab,gh,gh | depart,roundabout-exit-5,arrive |  ,;;;;;, |
+            | waypoints | route       | turns                                                 | lanes    |
+            | a,h       | ab,gh,gh,gh | depart,roundabout-exit-5,exit roundabout right,arrive |  ,;;;;,, |
 
     @anticipate
     Scenario: No Lanes for Roundabouts, see #2626
@@ -569,16 +569,16 @@ Feature: Turn Lane Guidance
             | nodes | turn:lanes:forward         | highway | junction   | name       |
             | xb    | slight_right\|slight_right | primary |            | xb         |
             | dy    |                            | primary |            | dy         |
-            | ab    |                            | primary | roundabout | roundabout |
-            | bc    |                            | primary | roundabout | roundabout |
-            | cd    | left\|slight_right         | primary | roundabout | roundabout |
-            | da    |                            | primary | roundabout | roundabout |
+            | ab    |                            | primary | roundabout | rotary     |
+            | bc    |                            | primary | roundabout | rotary     |
+            | cd    | left\|slight_right         | primary | roundabout | rotary     |
+            | da    |                            | primary | roundabout | rotary     |
 
         When I route I should get
-            | waypoints | route                    | turns                                   | lanes |
-            | x,y       | xb,dy,dy                 | depart,roundabout-exit-1,arrive         | ,;,   |
-            | x,c       | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,,    |
-            | x,a       | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,;,   |
+            | waypoints | route            | turns                                         | lanes |
+            | x,y       | xb,dy,dy,dy      | depart,rotary-exit-1,exit rotary right,arrive | ,,,   |
+            | x,c       | xb,rotary,rotary | depart,rotary-exit-undefined,arrive           | ,,    |
+            | x,a       | xb,rotary,rotary | depart,rotary-exit-undefined,arrive           | ,;,   |
 
     @anticipate
     Scenario: No Lanes for Roundabouts, see #2626
@@ -614,8 +614,8 @@ Feature: Turn Lane Guidance
             | fy    |                            | primary |            |
 
         When I route I should get
-            | waypoints | route      | turns                           | lanes      |
-            | a,h       | ab,ch,ch   | depart,roundabout-exit-5,arrive | ,;;;;;,    |
+            | waypoints | route       | turns                                                | lanes      |
+            | a,h       | ab,ch,ch,ch | depart,roundabout-exit-5,exit roundabout left,arrive | ,;;;;,,    |
 
     @anticipate
     Scenario: No Lanes for Roundabouts, see #2626
@@ -635,16 +635,16 @@ Feature: Turn Lane Guidance
             | nodes | turn:lanes:forward         | highway | junction   | name       |
             | xb    | slight_right\|slight_right | primary |            | xb         |
             | dy    |                            | primary |            | dy         |
-            | ab    |                            | primary | roundabout | roundabout |
-            | bc    |                            | primary | roundabout | roundabout |
-            | cd    | left\|slight_right         | primary | roundabout | roundabout |
-            | da    |                            | primary | roundabout | roundabout |
+            | ab    |                            | primary | roundabout | rotary     |
+            | bc    |                            | primary | roundabout | rotary     |
+            | cd    | left\|slight_right         | primary | roundabout | rotary     |
+            | da    |                            | primary | roundabout | rotary     |
 
         When I route I should get
-            | waypoints | route                    | turns                                   | lanes |
-            | x,y       | xb,dy,dy                 | depart,roundabout-exit-1,arrive         | ,;,   |
-            | x,c       | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,,    |
-            | x,a       | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,;,   |
+            | waypoints | route            | turns                                         | lanes |
+            | x,y       | xb,dy,dy,dy      | depart,rotary-exit-1,exit rotary right,arrive | ,,,   |
+            | x,c       | xb,rotary,rotary | depart,rotary-exit-undefined,arrive           | ,,    |
+            | x,a       | xb,rotary,rotary | depart,rotary-exit-undefined,arrive           | ,;,   |
 
     @anticipate @todo @2032
     Scenario: No Lanes for Roundabouts, see #2626
@@ -780,8 +780,8 @@ Feature: Turn Lane Guidance
             | dy    |                                | YSt  |
 
        When I route I should get
-            | waypoints | route               | turns                                   | lanes                                                                        |
-            | a,e       | MySt,MySt,MySt,MySt | depart,continue right,turn right,arrive | ,straight:false straight:false right:false right:true,left:false right:true, |
+            | waypoints | route               | turns                                       | lanes                                                                        |
+            | a,e       | MySt,MySt,MySt,MySt | depart,continue right,continue right,arrive | ,straight:false straight:false right:false right:true,left:false right:true, |
 
     @anticipate
     Scenario: Don't Overdo It

features/guidance/circular.feature

@@ -1,5 +1,8 @@
 @routing  @guidance
-Feature: Rotary
+Feature: Circular
+
+    # Circular tags are treated just as rotaries. We can rely on the rotary tests for their handling on special cases.
+    # Here we only ensure that the `circular` tag is handled and assigned a rotary type
 
     Background:
         Given the profile "car"
@@ -24,259 +27,16 @@ Feature: Rotary
             | bgecb  | circular |
 
        When I route I should get
-           | waypoints | route    | turns                      |
-           | a,d       | ab,cd,cd | depart,bgecb-exit-3,arrive |
-           | a,f       | ab,ef,ef | depart,bgecb-exit-2,arrive |
-           | a,h       | ab,gh,gh | depart,bgecb-exit-1,arrive |
-           | d,f       | cd,ef,ef | depart,bgecb-exit-3,arrive |
-           | d,h       | cd,gh,gh | depart,bgecb-exit-2,arrive |
-           | d,a       | cd,ab,ab | depart,bgecb-exit-1,arrive |
-           | f,h       | ef,gh,gh | depart,bgecb-exit-3,arrive |
-           | f,a       | ef,ab,ab | depart,bgecb-exit-2,arrive |
-           | f,d       | ef,cd,cd | depart,bgecb-exit-1,arrive |
-           | h,a       | gh,ab,ab | depart,bgecb-exit-3,arrive |
-           | h,d       | gh,cd,cd | depart,bgecb-exit-2,arrive |
-           | h,f       | gh,ef,ef | depart,bgecb-exit-1,arrive |
-
-    Scenario: Only Enter
-        Given the node map
-            """
-                a
-                b
-            d c   g h
-                e
-                f
-            """
-
-       And the ways
-            | nodes  | junction |
-            | ab     |          |
-            | cd     |          |
-            | ef     |          |
-            | gh     |          |
-            | bcegb  | circular |
-
-       When I route I should get
-           | waypoints | route          | turns                              |
-           | a,c       | ab,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | a,e       | ab,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | a,g       | ab,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | d,e       | cd,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | d,g       | cd,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | d,b       | cd,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | f,g       | ef,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | f,b       | ef,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | f,c       | ef,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | h,b       | gh,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | h,c       | gh,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | h,e       | gh,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-
-    Scenario: Only Exit
-        Given the node map
-            """
-                a
-                b
-            d c   g h
-                e
-                f
-            """
-
-       And the ways
-            | nodes  | junction |
-            | ab     |          |
-            | cd     |          |
-            | ef     |          |
-            | gh     |          |
-            | bcegb  | circular |
-
-       When I route I should get
-           | waypoints | route       | turns                      |
-           | b,d       | bcegb,cd,cd | depart,bcegb-exit-1,arrive |
-           | b,f       | bcegb,ef,ef | depart,bcegb-exit-2,arrive |
-           | b,h       | bcegb,gh,gh | depart,bcegb-exit-3,arrive |
-           | c,f       | bcegb,ef,ef | depart,bcegb-exit-1,arrive |
-           | c,h       | bcegb,gh,gh | depart,bcegb-exit-2,arrive |
-           | c,a       | bcegb,ab,ab | depart,bcegb-exit-3,arrive |
-           | e,h       | bcegb,gh,gh | depart,bcegb-exit-1,arrive |
-           | e,a       | bcegb,ab,ab | depart,bcegb-exit-2,arrive |
-           | e,d       | bcegb,cd,cd | depart,bcegb-exit-3,arrive |
-           | g,a       | bcegb,ab,ab | depart,bcegb-exit-1,arrive |
-           | g,d       | bcegb,cd,cd | depart,bcegb-exit-2,arrive |
-           | g,f       | bcegb,ef,ef | depart,bcegb-exit-3,arrive |
-      #phantom node snapping can result in a full round-trip here, therefore we cannot test b->a and the other direct exits
-
-    Scenario: Drive Around
-        Given the node map
-            """
-                a
-                b
-            d c   g h
-                e
-                f
-            """
-
-       And the ways
-            | nodes  | junction   |
-            | ab     |            |
-            | cd     |            |
-            | ef     |            |
-            | gh     |            |
-            | bcegb  | circular   |
-
-       When I route I should get
-           | waypoints | route       | turns         |
-           | b,c       | bcegb,bcegb | depart,arrive |
-           | b,e       | bcegb,bcegb | depart,arrive |
-           | b,g       | bcegb,bcegb | depart,arrive |
-           | c,e       | bcegb,bcegb | depart,arrive |
-           | c,g       | bcegb,bcegb | depart,arrive |
-           | c,b       | bcegb,bcegb | depart,arrive |
-           | e,g       | bcegb,bcegb | depart,arrive |
-           | e,b       | bcegb,bcegb | depart,arrive |
-           | e,c       | bcegb,bcegb | depart,arrive |
-           | g,b       | bcegb,bcegb | depart,arrive |
-           | g,c       | bcegb,bcegb | depart,arrive |
-           | g,e       | bcegb,bcegb | depart,arrive |
-
-     #needs to be adjusted when name-discovery works for entrys
-     Scenario: Mixed Entry and Exit
-        Given the node map
-           """
-             c   a
-           j   b   f
-             k   e
-           l   h   d
-             g   i
-           """
-
-        And the ways
-           | nodes | junction | oneway |
-           | abc   |          | yes    |
-           | def   |          | yes    |
-           | ghi   |          | yes    |
-           | jkl   |          | yes    |
-           | bkheb | circular | yes    |
-
-        When I route I should get
-           | waypoints | route       | turns                       |
-           | a,c       | abc,abc,abc | depart,rotary-exit-1,arrive |
-           | a,l       | abc,jkl,jkl | depart,bkheb-exit-2,arrive  |
-           | a,i       | abc,ghi,ghi | depart,bkheb-exit-3,arrive  |
-           | a,f       | abc,def,def | depart,bkheb-exit-4,arrive  |
-           | d,f       | def,def,def | depart,rotary-exit-1,arrive |
-           | d,c       | def,abc,abc | depart,bkheb-exit-2,arrive  |
-           | d,l       | def,jkl,jkl | depart,bkheb-exit-3,arrive  |
-           | d,i       | def,ghi,ghi | depart,bkheb-exit-4,arrive  |
-           | g,i       | ghi,ghi,ghi | depart,rotary-exit-1,arrive |
-           | g,f       | ghi,def,def | depart,bkheb-exit-2,arrive  |
-           | g,c       | ghi,abc,abc | depart,bkheb-exit-3,arrive  |
-           | g,l       | ghi,jkl,jkl | depart,bkheb-exit-4,arrive  |
-           | j,l       | jkl,jkl,jkl | depart,rotary-exit-1,arrive |
-           | j,i       | jkl,ghi,ghi | depart,bkheb-exit-2,arrive  |
-           | j,f       | jkl,def,def | depart,bkheb-exit-3,arrive  |
-           | j,c       | jkl,abc,abc | depart,bkheb-exit-4,arrive  |
-
-       Scenario: Collinear in X,Y
-        Given the node map
-            """
-            a
-            b
-            c d f
-            e
-            """
-
-        And the ways
-            | nodes | junction |
-            | ab    |          |
-            | bcdb  | circular |
-            | ce    |          |
-            | df    |          |
-
-        When I route I should get
-            | waypoints | route    | turns                     |
-            | a,e       | ab,ce,ce | depart,bcdb-exit-1,arrive |
-            | a,f       | ab,df,df | depart,bcdb-exit-2,arrive |
-
-       Scenario: Collinear in X,Y
-        Given the node map
-            """
-            a
-            d
-            b c f
-            e
-            """
-
-        And the ways
-            | nodes | junction |
-            | ad    |          |
-            | bcdb  | circular |
-            | be    |          |
-            | cf    |          |
-
-        When I route I should get
-            | waypoints | route    | turns                     |
-            | a,e       | ad,be,be | depart,bcdb-exit-1,arrive |
-            | a,f       | ad,cf,cf | depart,bcdb-exit-2,arrive |
-
-       Scenario: Collinear in X,Y
-        Given the node map
-            """
-            a
-            c
-            d b f
-            e
-            """
-
-        And the ways
-            | nodes | junction |
-            | ac    |          |
-            | bcdb  | circular |
-            | de    |          |
-            | bf    |          |
-
-        When I route I should get
-            | waypoints | route    | turns                     |
-            | a,e       | ac,de,de | depart,bcdb-exit-1,arrive |
-            | a,f       | ac,bf,bf | depart,bcdb-exit-2,arrive |
-
-       Scenario: Collinear in X,Y
-        Given the node map
-            """
-            f
-            d c e
-              b
-              a
-            """
-
-        And the ways
-            | nodes | junction |
-            | ab    |          |
-            | bcdb  | circular |
-            | ce    |          |
-            | df    |          |
-
-        When I route I should get
-            | waypoints | route    | turns                     |
-            | a,e       | ab,ce,ce | depart,bcdb-exit-1,arrive |
-            | a,f       | ab,df,df | depart,bcdb-exit-2,arrive |
-
-       Scenario: Collinear in X,Y
-        Given the node map
-            """
-            f
-            d c e
-            b
-            a
-            """
-
-        And the ways
-            | nodes | junction |
-            | ab    |          |
-            | bcdb  | circular |
-            | ce    |            |
-            | df    |            |
-
-        When I route I should get
-            | waypoints | route    | turns                     |
-            | a,e       | ab,ce,ce | depart,bcdb-exit-1,arrive |
-            | a,f       | ab,df,df | depart,bcdb-exit-2,arrive |
+           | waypoints | route       | turns                                        |
+           | a,d       | ab,cd,cd,cd | depart,bgecb-exit-3,exit rotary right,arrive |
+           | a,f       | ab,ef,ef,ef | depart,bgecb-exit-2,exit rotary right,arrive |
+           | a,h       | ab,gh,gh,gh | depart,bgecb-exit-1,exit rotary right,arrive |
+           | d,f       | cd,ef,ef,ef | depart,bgecb-exit-3,exit rotary right,arrive |
+           | d,h       | cd,gh,gh,gh | depart,bgecb-exit-2,exit rotary right,arrive |
+           | d,a       | cd,ab,ab,ab | depart,bgecb-exit-1,exit rotary right,arrive |
+           | f,h       | ef,gh,gh,gh | depart,bgecb-exit-3,exit rotary right,arrive |
+           | f,a       | ef,ab,ab,ab | depart,bgecb-exit-2,exit rotary right,arrive |
+           | f,d       | ef,cd,cd,cd | depart,bgecb-exit-1,exit rotary right,arrive |
+           | h,a       | gh,ab,ab,ab | depart,bgecb-exit-3,exit rotary right,arrive |
+           | h,d       | gh,cd,cd,cd | depart,bgecb-exit-2,exit rotary right,arrive |
+           | h,f       | gh,ef,ef,ef | depart,bgecb-exit-1,exit rotary right,arrive |

features/guidance/collapse.feature

@@ -628,9 +628,9 @@ Feature: Collapse
             | cf    | secondary | bottom |
 
         When I route I should get
-            | waypoints | turns                                   | route               | locations |
-            | a,d       | depart,continue right,turn right,arrive | road,road,road,road | a,b,c,d   |
-            | d,a       | depart,continue left,turn left,arrive   | road,road,road,road | d,c,b,a   |
+            | waypoints | turns                                       | route               | locations |
+            | a,d       | depart,continue right,continue right,arrive | road,road,road,road | a,b,c,d   |
+            | d,a       | depart,continue left,continue left,arrive   | road,road,road,road | d,c,b,a   |
 
     Scenario: Forking before a turn
         Given the node map

features/guidance/continue.feature

@@ -136,3 +136,24 @@ Feature: Continue Instructions
           | a,d       | abcdefb,abcdefb,abcdefb | depart,continue right,arrive |
           # continuing right here, since the turn to the left is more expensive
           | a,e       | abcdefb,abcdefb,abcdefb | depart,continue right,arrive |
+
+    Scenario: End-Of-Road Continue
+        Given the node map
+            """
+            a - b - c
+                |
+                d - e
+                |
+                f
+            """
+
+        And the ways
+            | nodes | highway | name |
+            | abc   | primary | road |
+            | bdf   | primary | road |
+            | ed    | primary | turn |
+
+
+        When I route I should get
+            | waypoints | route               | turns                                  |
+            | e,a       | turn,road,road,road | depart,turn right,continue left,arrive |

features/guidance/dedicated-turn-roads.feature

@@ -863,8 +863,8 @@ Feature: Slipways and Dedicated Turn Lanes
             | af    | primary | sliproad | yes    |
 
        When I route I should get
-            | waypoints | route                         | turns                              | locations |
-            | s,g       | main,sliproad,another,another | depart,turn right,turn left,arrive | s,a,f,g   |
+            | waypoints | route                         | turns                                     | locations |
+            | s,g       | main,sliproad,another,another | depart,turn right,turn slight left,arrive | s,a,f,g   |
 
     @sliproads:
     Scenario: Throughabout-Sliproad
@@ -905,8 +905,8 @@ Feature: Slipways and Dedicated Turn Lanes
             | restriction | yb       | be     | b        | only_straight |
 
         When I route I should get
-            | waypoints | route            | turns                                            | locations |
-            | z,t       | through,,out,out | depart,off ramp slight right,round-exit-3,arrive | z,s,c,t   |
+            | waypoints | route                | turns                                                              | locations |
+            | z,t       | through,,out,out,out | depart,off ramp slight right,round-exit-3,exit rotary right,arrive | z,s,c,e,t |
 
     Scenario: Sliproad before a roundabout
         Given the node map
@@ -942,5 +942,57 @@ Feature: Slipways and Dedicated Turn Lanes
             | restriction | bc       | cd     | c        | only_straight |
 
         When I route I should get
-            | waypoints | route     | turns                                                 | locations |
-            | a,k       | road,,,   | depart,turn right,roundabout turn right exit-1,arrive | a,b,h,k   |
+            | waypoints | route    | turns                                                 | locations |
+            | a,k       | road,,,  | depart,turn right,roundabout turn right exit-1,arrive | a,b,h,k   |
+
+    @sliproads
+    Scenario: Sliproad with 4 roads at target
+        Given the node map
+            """
+                    d
+                    .
+            s . a . b  . c . t
+                 `  .   '
+                  ` .  '
+                   '.'
+                    e
+                    .
+                    f
+            """
+
+        And the ways
+            | nodes | highway      | name  | oneway |
+            | sabct | primary      | sabct |        |
+            | dbef  | primary      | dbef  |        |
+            | ae    | primary_link | ae    | yes    |
+            | ec    | primary_link | ec    | yes    |
+
+       When I route I should get
+            | waypoints | route            | turns                    | locations |
+            | s,f       | sabct,dbef,dbef  | depart,turn right,arrive | s,a,f     |
+            | f,t       | dbef,sabct,sabct | depart,turn right,arrive | f,e,t     |
+
+    @sliproads
+    Scenario: Sliproad and acute angle (50°) at the main intersection
+        Given the node map
+            """
+                          d
+                         /
+            s . a . .  b  . c
+                 `    /
+                  ' /
+                  e
+                 /
+                f
+            """
+
+        And the ways
+            | nodes | highway      | name  | oneway |
+            | sabc  | primary      | sabc  |        |
+            | dbef  | primary      | dbef  |        |
+            | ae    | primary_link | ae    | yes    |
+
+
+       When I route I should get
+            | waypoints | route          | turns                    | locations |
+            | s,f       | sabc,dbef,dbef | depart,turn right,arrive | s,a,f     |

features/guidance/divided-highways.feature

@@ -0,0 +1,102 @@
+@routing  @guidance
+Feature: Divided road entry
+
+    Background:
+        Given the profile "car"
+        Given a grid size of 5 meters
+
+    Scenario: Join on a divided road named after the main road
+        Given the node map
+            """
+            a-------b-----c
+                    |
+            d-------e-----f
+                    |
+                    |
+                    g
+            """
+
+        And the ways
+            | nodes  | name    | highway     | oneway |
+            | abc    | main st | residential | -1     |
+            | def    | main st | residential | yes    |
+            | be     | main st | residential |        |
+            | eg     | side st | residential |        |
+
+       When I route I should get
+            | waypoints | route                  | turns                   |
+            | g,a       | side st,main st,main st| depart,end of road left,arrive |
+
+
+    # Similar to previous one, but the joining way is tagged with the side-street name
+    Scenario: Join on a divided road, named after the side street
+        Given the node map
+            """
+            a-------b-----c
+                    |
+            d-------e-----f
+                    |
+                    |
+                    g
+            """
+
+        And the ways
+            | nodes  | name    | highway     | oneway |
+            | abc    | main st | residential | -1     |
+            | def    | main st | residential | yes    |
+            | beg    | side st | residential |        |
+
+       When I route I should get
+            | waypoints | route    | turns                           |
+            | g,a       | side st,main st,main st| depart,end of road left,arrive |
+
+
+    # Center join named after crossroad
+    Scenario: Crossing a divided road, named after side-street
+        Given the node map
+            """
+                    h
+                    |
+            a-------b-----c
+                    |
+            d-------e-----f
+                    |
+                    |
+                    g
+            """
+
+        And the ways
+            | nodes  | name    | highway     | oneway |
+            | abc    | main st | residential | -1     |
+            | def    | main st | residential | yes    |
+            | hbeg   | side st | residential |        |
+
+       When I route I should get
+            | waypoints | route    | turns                           |
+            | g,a       | side st,main st,main st| depart,turn left,arrive |
+
+    # Join named after divided road
+    Scenario: Crossing a divided road, named after main street
+        Given the node map
+            """
+                    h
+                    |
+            a-------b-----c
+                    |
+            d-------e-----f
+                    |
+                    |
+                    g
+            """
+
+        And the ways
+            | nodes  | name    | highway     | oneway |
+            | abc    | main st | residential | -1     |
+            | def    | main st | residential | yes    |
+            | be     | main st | residential |        |
+            | hb     | side st | residential |        |
+            | eg     | side st | residential |        |
+
+       When I route I should get
+            | waypoints | route    | turns                           |
+            | g,a       | side st,main st,main st| depart,turn left,arrive |

features/guidance/intersections.feature

@@ -140,9 +140,9 @@ Feature: Intersections Data
 
         When I route I should get
             | waypoints | route          | intersections                                                                                                                 |
-            | e,f       | ea,fb,fb       | true:180;false:0 false:150 true:210,false:30 true:150 true:270;true:90                                                        |
-            | e,g       | ea,gc,gc       | true:180;false:0 false:150 true:210,false:30 true:150 true:270,true:30 true:180 false:330;true:0                              |
-            | e,h       | ea,hd,hd       | true:180;false:0 false:150 true:210,false:30 true:150 true:270,true:30 true:180 false:330,true:90 false:210 true:330;true:270 |
+            | e,f       | ea,fb,fb,fb    | true:180;false:0 false:150 true:210;false:30 true:150 true:270;true:90                                                        |
+            | e,g       | ea,gc,gc,gc    | true:180;false:0 false:150 true:210,false:30 true:150 true:270;true:30 true:180 false:330;true:0                              |
+            | e,h       | ea,hd,hd,hd    | true:180;false:0 false:150 true:210,false:30 true:150 true:270,true:30 true:180 false:330;true:90 false:210 true:330;true:270 |
             | e,2       | ea,abcda,abcda | true:180;false:0 false:150 true:210,false:30 true:150 true:270;true:327 +-1                                                   |
-            | 1,g       | abcda,gc,gc    | true:214;false:30 true:150 true:270,true:30 true:180 false:330;true:0                                                         |
+            | 1,g       | abcda,gc,gc    | true:214,false:30 true:150 true:270;true:30 true:180 false:330;true:0                                                         |
             | 1,3       | abcda,abcda    | true:214,false:30 true:150 true:270,true:30 true:180 false:330;true:214                                                       |

features/guidance/perception.feature

@@ -97,5 +97,7 @@ Feature: Simple Turns
             | ei    | left  | yes    |
 
         When I route I should get
-            | waypoints | route        | turns                    |
-            | g,a       | in,road,road | depart,fork right,arrive |
+            | waypoints | route          | turns                           |
+            | g,a       | in,road,road   | depart,fork slight right,arrive |
+            | g,h       | in,right,right | depart,fork straight,arrive     |
+            | g,i       | in,left,left   | depart,fork slight left,arrive  |

features/guidance/rotary-bike.feature

@@ -1,177 +0,0 @@
-@routing  @guidance
-Feature: Rotary
-
-    Background:
-        Given the profile "bicycle"
-        Given a grid size of 30 meters
-
-    Scenario: Enter and Exit
-        Given the node map
-            """
-                a
-                b
-            h g   c d
-                e
-                f
-            """
-
-       And the ways
-            | nodes  | junction   |
-            | ab     |            |
-            | cd     |            |
-            | ef     |            |
-            | gh     |            |
-            | bgecb  | roundabout |
-
-       When I route I should get
-           | waypoints | route    | turns                      |
-           | a,d       | ab,cd,cd | depart,bgecb-exit-3,arrive |
-           | a,f       | ab,ef,ef | depart,bgecb-exit-2,arrive |
-           | a,h       | ab,gh,gh | depart,bgecb-exit-1,arrive |
-           | d,f       | cd,ef,ef | depart,bgecb-exit-3,arrive |
-           | d,h       | cd,gh,gh | depart,bgecb-exit-2,arrive |
-           | d,a       | cd,ab,ab | depart,bgecb-exit-1,arrive |
-           | f,h       | ef,gh,gh | depart,bgecb-exit-3,arrive |
-           | f,a       | ef,ab,ab | depart,bgecb-exit-2,arrive |
-           | f,d       | ef,cd,cd | depart,bgecb-exit-1,arrive |
-           | h,a       | gh,ab,ab | depart,bgecb-exit-3,arrive |
-           | h,d       | gh,cd,cd | depart,bgecb-exit-2,arrive |
-           | h,f       | gh,ef,ef | depart,bgecb-exit-1,arrive |
-
-    Scenario: Only Enter
-        Given the node map
-            """
-                a
-                b
-            d c   g h
-                e
-                f
-            """
-
-       And the ways
-            | nodes  | junction   |
-            | ab     |            |
-            | cd     |            |
-            | ef     |            |
-            | gh     |            |
-            | bcegb  | roundabout |
-
-       When I route I should get
-           | waypoints | route          | turns                              |
-           | a,c       | ab,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | a,e       | ab,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | a,g       | ab,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | d,e       | cd,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | d,g       | cd,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | d,b       | cd,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | f,g       | ef,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | f,b       | ef,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | f,c       | ef,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | h,b       | gh,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | h,c       | gh,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-           | h,e       | gh,bcegb,bcegb | depart,bcegb-exit-undefined,arrive |
-
-    Scenario: Only Exit
-        Given the node map
-            """
-                a
-                b
-            d c   g h
-                e
-                f
-            """
-
-       And the ways
-            | nodes  | junction   |
-            | ab     |            |
-            | cd     |            |
-            | ef     |            |
-            | gh     |            |
-            | bcegb  | roundabout |
-
-       When I route I should get
-           | waypoints | route       | turns                      |
-           | b,d       | bcegb,cd,cd | depart,bcegb-exit-1,arrive |
-           | b,f       | bcegb,ef,ef | depart,bcegb-exit-2,arrive |
-           | b,h       | bcegb,gh,gh | depart,bcegb-exit-3,arrive |
-           | c,f       | bcegb,ef,ef | depart,bcegb-exit-1,arrive |
-           | c,h       | bcegb,gh,gh | depart,bcegb-exit-2,arrive |
-           | c,a       | bcegb,ab,ab | depart,bcegb-exit-3,arrive |
-           | e,h       | bcegb,gh,gh | depart,bcegb-exit-1,arrive |
-           | e,a       | bcegb,ab,ab | depart,bcegb-exit-2,arrive |
-           | e,d       | bcegb,cd,cd | depart,bcegb-exit-3,arrive |
-           | g,a       | bcegb,ab,ab | depart,bcegb-exit-1,arrive |
-           | g,d       | bcegb,cd,cd | depart,bcegb-exit-2,arrive |
-           | g,f       | bcegb,ef,ef | depart,bcegb-exit-3,arrive |
-      #phantom node snapping can result in a full round-trip here, therefore we cannot test b->a and the other direct exits
-
-    Scenario: Drive Around
-        Given the node map
-            """
-                a
-                b
-            d c   g h
-                e
-                f
-            """
-
-       And the ways
-            | nodes  | junction   |
-            | ab     |            |
-            | cd     |            |
-            | ef     |            |
-            | gh     |            |
-            | bcegb  | roundabout |
-
-       When I route I should get
-           | waypoints | route       | turns         |
-           | b,c       | bcegb,bcegb | depart,arrive |
-           | b,e       | bcegb,bcegb | depart,arrive |
-           | b,g       | bcegb,bcegb | depart,arrive |
-           | c,e       | bcegb,bcegb | depart,arrive |
-           | c,g       | bcegb,bcegb | depart,arrive |
-           | c,b       | bcegb,bcegb | depart,arrive |
-           | e,g       | bcegb,bcegb | depart,arrive |
-           | e,b       | bcegb,bcegb | depart,arrive |
-           | e,c       | bcegb,bcegb | depart,arrive |
-           | g,b       | bcegb,bcegb | depart,arrive |
-           | g,c       | bcegb,bcegb | depart,arrive |
-           | g,e       | bcegb,bcegb | depart,arrive |
-
-     #needs to be adjusted when name-discovery works for entrys
-     Scenario: Mixed Entry and Exit
-        Given the node map
-           """
-             c   a
-           j   b   f
-             k   e
-           l   h   d
-             g   i
-           """
-
-        And the ways
-           | nodes | junction   | oneway |
-           | abc   |            | yes    |
-           | def   |            | yes    |
-           | ghi   |            | yes    |
-           | jkl   |            | yes    |
-           | bkheb | roundabout | yes    |
-
-        When I route I should get
-           | waypoints | route       | turns                       |
-           | a,c       | abc,abc,abc | depart,rotary-exit-1,arrive |
-           | a,l       | abc,jkl,jkl | depart,bkheb-exit-2,arrive  |
-           | a,i       | abc,ghi,ghi | depart,bkheb-exit-3,arrive  |
-           | a,f       | abc,def,def | depart,bkheb-exit-4,arrive  |
-           | d,f       | def,def,def | depart,rotary-exit-1,arrive |
-           | d,c       | def,abc,abc | depart,bkheb-exit-2,arrive  |
-           | d,l       | def,jkl,jkl | depart,bkheb-exit-3,arrive  |
-           | d,i       | def,ghi,ghi | depart,bkheb-exit-4,arrive  |
-           | g,i       | ghi,ghi,ghi | depart,rotary-exit-1,arrive |
-           | g,f       | ghi,def,def | depart,bkheb-exit-2,arrive  |
-           | g,c       | ghi,abc,abc | depart,bkheb-exit-3,arrive  |
-           | g,l       | ghi,jkl,jkl | depart,bkheb-exit-4,arrive  |
-           | j,l       | jkl,jkl,jkl | depart,rotary-exit-1,arrive |
-           | j,i       | jkl,ghi,ghi | depart,bkheb-exit-2,arrive  |
-           | j,f       | jkl,def,def | depart,bkheb-exit-3,arrive  |
-           | j,c       | jkl,abc,abc | depart,bkheb-exit-4,arrive  |

features/guidance/rotary.feature

@@ -24,19 +24,19 @@ Feature: Rotary
             | bgecb  | roundabout |
 
        When I route I should get
-           | waypoints | route    | turns                      |
-           | a,d       | ab,cd,cd | depart,bgecb-exit-3,arrive |
-           | a,f       | ab,ef,ef | depart,bgecb-exit-2,arrive |
-           | a,h       | ab,gh,gh | depart,bgecb-exit-1,arrive |
-           | d,f       | cd,ef,ef | depart,bgecb-exit-3,arrive |
-           | d,h       | cd,gh,gh | depart,bgecb-exit-2,arrive |
-           | d,a       | cd,ab,ab | depart,bgecb-exit-1,arrive |
-           | f,h       | ef,gh,gh | depart,bgecb-exit-3,arrive |
-           | f,a       | ef,ab,ab | depart,bgecb-exit-2,arrive |
-           | f,d       | ef,cd,cd | depart,bgecb-exit-1,arrive |
-           | h,a       | gh,ab,ab | depart,bgecb-exit-3,arrive |
-           | h,d       | gh,cd,cd | depart,bgecb-exit-2,arrive |
-           | h,f       | gh,ef,ef | depart,bgecb-exit-1,arrive |
+           | waypoints | route       | turns                                        |
+           | a,d       | ab,cd,cd,cd | depart,bgecb-exit-3,exit rotary right,arrive |
+           | a,f       | ab,ef,ef,ef | depart,bgecb-exit-2,exit rotary right,arrive |
+           | a,h       | ab,gh,gh,gh | depart,bgecb-exit-1,exit rotary right,arrive |
+           | d,f       | cd,ef,ef,ef | depart,bgecb-exit-3,exit rotary right,arrive |
+           | d,h       | cd,gh,gh,gh | depart,bgecb-exit-2,exit rotary right,arrive |
+           | d,a       | cd,ab,ab,ab | depart,bgecb-exit-1,exit rotary right,arrive |
+           | f,h       | ef,gh,gh,gh | depart,bgecb-exit-3,exit rotary right,arrive |
+           | f,a       | ef,ab,ab,ab | depart,bgecb-exit-2,exit rotary right,arrive |
+           | f,d       | ef,cd,cd,cd | depart,bgecb-exit-1,exit rotary right,arrive |
+           | h,a       | gh,ab,ab,ab | depart,bgecb-exit-3,exit rotary right,arrive |
+           | h,d       | gh,cd,cd,cd | depart,bgecb-exit-2,exit rotary right,arrive |
+           | h,f       | gh,ef,ef,ef | depart,bgecb-exit-1,exit rotary right,arrive |
 
     Scenario: Only Enter
         Given the node map
@@ -90,19 +90,19 @@ Feature: Rotary
             | bcegb  | roundabout |
 
        When I route I should get
-           | waypoints | route       | turns                      |
-           | b,d       | bcegb,cd,cd | depart,bcegb-exit-1,arrive |
-           | b,f       | bcegb,ef,ef | depart,bcegb-exit-2,arrive |
-           | b,h       | bcegb,gh,gh | depart,bcegb-exit-3,arrive |
-           | c,f       | bcegb,ef,ef | depart,bcegb-exit-1,arrive |
-           | c,h       | bcegb,gh,gh | depart,bcegb-exit-2,arrive |
-           | c,a       | bcegb,ab,ab | depart,bcegb-exit-3,arrive |
-           | e,h       | bcegb,gh,gh | depart,bcegb-exit-1,arrive |
-           | e,a       | bcegb,ab,ab | depart,bcegb-exit-2,arrive |
-           | e,d       | bcegb,cd,cd | depart,bcegb-exit-3,arrive |
-           | g,a       | bcegb,ab,ab | depart,bcegb-exit-1,arrive |
-           | g,d       | bcegb,cd,cd | depart,bcegb-exit-2,arrive |
-           | g,f       | bcegb,ef,ef | depart,bcegb-exit-3,arrive |
+           | waypoints | route       | turns                           |
+           | b,d       | bcegb,cd,cd | depart,exit rotary right,arrive |
+           | b,f       | bcegb,ef,ef | depart,exit rotary right,arrive |
+           | b,h       | bcegb,gh,gh | depart,exit rotary right,arrive |
+           | c,f       | bcegb,ef,ef | depart,exit rotary right,arrive |
+           | c,h       | bcegb,gh,gh | depart,exit rotary right,arrive |
+           | c,a       | bcegb,ab,ab | depart,exit rotary right,arrive |
+           | e,h       | bcegb,gh,gh | depart,exit rotary right,arrive |
+           | e,a       | bcegb,ab,ab | depart,exit rotary right,arrive |
+           | e,d       | bcegb,cd,cd | depart,exit rotary right,arrive |
+           | g,a       | bcegb,ab,ab | depart,exit rotary right,arrive |
+           | g,d       | bcegb,cd,cd | depart,exit rotary right,arrive |
+           | g,f       | bcegb,ef,ef | depart,exit rotary right,arrive |
       #phantom node snapping can result in a full round-trip here, therefore we cannot test b->a and the other direct exits
 
     Scenario: Drive Around
@@ -158,23 +158,23 @@ Feature: Rotary
            | bkheb | roundabout | yes    |
 
         When I route I should get
-           | waypoints | route       | turns                       |
-           | a,c       | abc,abc,abc | depart,rotary-exit-1,arrive |
-           | a,l       | abc,jkl,jkl | depart,bkheb-exit-2,arrive  |
-           | a,i       | abc,ghi,ghi | depart,bkheb-exit-3,arrive  |
-           | a,f       | abc,def,def | depart,bkheb-exit-4,arrive  |
-           | d,f       | def,def,def | depart,rotary-exit-1,arrive |
-           | d,c       | def,abc,abc | depart,bkheb-exit-2,arrive  |
-           | d,l       | def,jkl,jkl | depart,bkheb-exit-3,arrive  |
-           | d,i       | def,ghi,ghi | depart,bkheb-exit-4,arrive  |
-           | g,i       | ghi,ghi,ghi | depart,rotary-exit-1,arrive |
-           | g,f       | ghi,def,def | depart,bkheb-exit-2,arrive  |
-           | g,c       | ghi,abc,abc | depart,bkheb-exit-3,arrive  |
-           | g,l       | ghi,jkl,jkl | depart,bkheb-exit-4,arrive  |
-           | j,l       | jkl,jkl,jkl | depart,rotary-exit-1,arrive |
-           | j,i       | jkl,ghi,ghi | depart,bkheb-exit-2,arrive  |
-           | j,f       | jkl,def,def | depart,bkheb-exit-3,arrive  |
-           | j,c       | jkl,abc,abc | depart,bkheb-exit-4,arrive  |
+           | waypoints | route       	 | turns                       					   |
+		   | a,c       | abc,abc,abc 	 | depart,exit rotary right,arrive   			   |
+		   | a,l       | abc,jkl,jkl,jkl | depart,bkheb-exit-2,exit rotary straight,arrive |
+		   | a,i       | abc,ghi,ghi,ghi | depart,bkheb-exit-3,exit rotary straight,arrive |
+		   | a,f       | abc,def,def,def | depart,bkheb-exit-4,exit rotary straight,arrive |
+		   | d,f       | def,def,def 	 | depart,exit rotary right,arrive 			       |
+		   | d,c       | def,abc,abc,abc | depart,bkheb-exit-2,exit rotary straight,arrive |
+		   | d,l       | def,jkl,jkl,jkl | depart,bkheb-exit-3,exit rotary straight,arrive |
+		   | d,i       | def,ghi,ghi,ghi | depart,bkheb-exit-4,exit rotary straight,arrive |
+		   | g,i       | ghi,ghi,ghi 	 | depart,exit rotary right,arrive 			       |
+		   | g,f       | ghi,def,def,def | depart,bkheb-exit-2,exit rotary straight,arrive |
+		   | g,c       | ghi,abc,abc,abc | depart,bkheb-exit-3,exit rotary straight,arrive |
+		   | g,l       | ghi,jkl,jkl,jkl | depart,bkheb-exit-4,exit rotary straight,arrive |
+		   | j,l       | jkl,jkl,jkl 	 | depart,exit rotary right,arrive 			       |
+		   | j,i       | jkl,ghi,ghi,ghi | depart,bkheb-exit-2,exit rotary straight,arrive |
+		   | j,f       | jkl,def,def,def | depart,bkheb-exit-3,exit rotary straight,arrive |
+		   | j,c       | jkl,abc,abc,abc | depart,bkheb-exit-4,exit rotary straight,arrive |
 
        Scenario: Collinear in X,Y
         Given the node map
@@ -193,9 +193,9 @@ Feature: Rotary
             | df    |            |
 
         When I route I should get
-            | waypoints | route    | turns                     |
-            | a,e       | ab,ce,ce | depart,bcdb-exit-1,arrive |
-            | a,f       | ab,df,df | depart,bcdb-exit-2,arrive |
+            | waypoints | route       | turns                     					   |
+            | a,e       | ab,ce,ce,ce | depart,bcdb-exit-1,exit rotary straight,arrive |
+            | a,f       | ab,df,df,df | depart,bcdb-exit-2,exit rotary straight,arrive |
 
        Scenario: Collinear in X,Y
         Given the node map
@@ -214,9 +214,9 @@ Feature: Rotary
             | cf    |            |
 
         When I route I should get
-            | waypoints | route    | turns                     |
-            | a,e       | ad,be,be | depart,bcdb-exit-1,arrive |
-            | a,f       | ad,cf,cf | depart,bcdb-exit-2,arrive |
+            | waypoints | route    	  | turns                     					   |
+            | a,e       | ad,be,be,be | depart,bcdb-exit-1,exit rotary straight,arrive |
+            | a,f       | ad,cf,cf,cf | depart,bcdb-exit-2,exit rotary straight,arrive |
 
        Scenario: Collinear in X,Y
         Given the node map
@@ -235,9 +235,9 @@ Feature: Rotary
             | bf    |            |
 
         When I route I should get
-            | waypoints | route    | turns                     |
-            | a,e       | ac,de,de | depart,bcdb-exit-1,arrive |
-            | a,f       | ac,bf,bf | depart,bcdb-exit-2,arrive |
+            | waypoints | route    	  | turns                     					   |
+            | a,e       | ac,de,de,de | depart,bcdb-exit-1,exit rotary straight,arrive |
+            | a,f       | ac,bf,bf,bf | depart,bcdb-exit-2,exit rotary straight,arrive |
 
        Scenario: Collinear in X,Y
         Given the node map
@@ -256,9 +256,9 @@ Feature: Rotary
             | df    |            |
 
         When I route I should get
-            | waypoints | route    | turns                     |
-            | a,e       | ab,ce,ce | depart,bcdb-exit-1,arrive |
-            | a,f       | ab,df,df | depart,bcdb-exit-2,arrive |
+            | waypoints | route    	  | turns                     					|
+            | a,e       | ab,ce,ce,ce | depart,bcdb-exit-1,exit rotary right,arrive |
+            | a,f       | ab,df,df,df | depart,bcdb-exit-2,exit rotary right,arrive |
 
        Scenario: Collinear in X,Y
         Given the node map
@@ -277,6 +277,6 @@ Feature: Rotary
             | df    |            |
 
         When I route I should get
-            | waypoints | route    | turns                     |
-            | a,e       | ab,ce,ce | depart,bcdb-exit-1,arrive |
-            | a,f       | ab,df,df | depart,bcdb-exit-2,arrive |
+            | waypoints | route    	  | turns                     					|
+            | a,e       | ab,ce,ce,ce | depart,bcdb-exit-1,exit rotary right,arrive |
+            | a,f       | ab,df,df,df | depart,bcdb-exit-2,exit rotary right,arrive |

features/guidance/roundabout-bike.feature

@@ -5,39 +5,6 @@ Feature: Basic Roundabout
         Given the profile "bicycle"
         Given a grid size of 10 meters
 
-    Scenario: Only Enter
-        Given the node map
-            """
-                a
-                b
-            d c   g h
-                e
-                f
-            """
-
-       And the ways
-            | nodes  | junction   |
-            | ab     |            |
-            | cd     |            |
-            | ef     |            |
-            | gh     |            |
-            | bcegb  | roundabout |
-
-       When I route I should get
-           | waypoints | route          | turns                                   |
-           | a,c       | ab,bcegb,bcegb | depart,roundabout-exit-undefined,arrive |
-           | a,e       | ab,bcegb,bcegb | depart,roundabout-exit-undefined,arrive |
-           | a,g       | ab,bcegb,bcegb | depart,roundabout-exit-undefined,arrive |
-           | d,e       | cd,bcegb,bcegb | depart,roundabout-exit-undefined,arrive |
-           | d,g       | cd,bcegb,bcegb | depart,roundabout-exit-undefined,arrive |
-           | d,b       | cd,bcegb,bcegb | depart,roundabout-exit-undefined,arrive |
-           | f,g       | ef,bcegb,bcegb | depart,roundabout-exit-undefined,arrive |
-           | f,b       | ef,bcegb,bcegb | depart,roundabout-exit-undefined,arrive |
-           | f,c       | ef,bcegb,bcegb | depart,roundabout-exit-undefined,arrive |
-           | h,b       | gh,bcegb,bcegb | depart,roundabout-exit-undefined,arrive |
-           | h,c       | gh,bcegb,bcegb | depart,roundabout-exit-undefined,arrive |
-           | h,e       | gh,bcegb,bcegb | depart,roundabout-exit-undefined,arrive |
-
     Scenario: Only Exit
         Given the node map
             """
@@ -57,54 +24,21 @@ Feature: Basic Roundabout
             | bcegb  | roundabout |
 
        When I route I should get
-           | waypoints | route       | turns                           |
-           | b,d       | bcegb,cd,cd | depart,roundabout-exit-1,arrive |
-           | b,f       | bcegb,ef,ef | depart,roundabout-exit-2,arrive |
-           | b,h       | bcegb,gh,gh | depart,roundabout-exit-3,arrive |
-           | c,f       | bcegb,ef,ef | depart,roundabout-exit-1,arrive |
-           | c,h       | bcegb,gh,gh | depart,roundabout-exit-2,arrive |
-           | c,a       | bcegb,ab,ab | depart,roundabout-exit-3,arrive |
-           | e,h       | bcegb,gh,gh | depart,roundabout-exit-1,arrive |
-           | e,a       | bcegb,ab,ab | depart,roundabout-exit-2,arrive |
-           | e,d       | bcegb,cd,cd | depart,roundabout-exit-3,arrive |
-           | g,a       | bcegb,ab,ab | depart,roundabout-exit-1,arrive |
-           | g,d       | bcegb,cd,cd | depart,roundabout-exit-2,arrive |
-           | g,f       | bcegb,ef,ef | depart,roundabout-exit-3,arrive |
+           | waypoints | route       | turns                               |
+           | b,d       | bcegb,cd,cd | depart,exit roundabout right,arrive |
+           | b,f       | bcegb,ef,ef | depart,exit roundabout right,arrive |
+           | b,h       | bcegb,gh,gh | depart,exit roundabout right,arrive |
+           | c,f       | bcegb,ef,ef | depart,exit roundabout right,arrive |
+           | c,h       | bcegb,gh,gh | depart,exit roundabout right,arrive |
+           | c,a       | bcegb,ab,ab | depart,exit roundabout right,arrive |
+           | e,h       | bcegb,gh,gh | depart,exit roundabout right,arrive |
+           | e,a       | bcegb,ab,ab | depart,exit roundabout right,arrive |
+           | e,d       | bcegb,cd,cd | depart,exit roundabout right,arrive |
+           | g,a       | bcegb,ab,ab | depart,exit roundabout right,arrive |
+           | g,d       | bcegb,cd,cd | depart,exit roundabout right,arrive |
+           | g,f       | bcegb,ef,ef | depart,exit roundabout right,arrive |
       #phantom node snapping can result in a full round-trip here, therefore we cannot test b->a and the other direct exits
 
-    Scenario: Drive Around
-        Given the node map
-            """
-                a
-                b
-            d c   g h
-                e
-                f
-            """
-
-       And the ways
-            | nodes  | junction   |
-            | ab     |            |
-            | cd     |            |
-            | ef     |            |
-            | gh     |            |
-            | bcegb  | roundabout |
-
-       When I route I should get
-           | waypoints | route       | turns         |
-           | b,c       | bcegb,bcegb | depart,arrive |
-           | b,e       | bcegb,bcegb | depart,arrive |
-           | b,g       | bcegb,bcegb | depart,arrive |
-           | c,e       | bcegb,bcegb | depart,arrive |
-           | c,g       | bcegb,bcegb | depart,arrive |
-           | c,b       | bcegb,bcegb | depart,arrive |
-           | e,g       | bcegb,bcegb | depart,arrive |
-           | e,b       | bcegb,bcegb | depart,arrive |
-           | e,c       | bcegb,bcegb | depart,arrive |
-           | g,b       | bcegb,bcegb | depart,arrive |
-           | g,c       | bcegb,bcegb | depart,arrive |
-           | g,e       | bcegb,bcegb | depart,arrive |
-
      Scenario: Mixed Entry and Exit
         Given the node map
            """
@@ -124,20 +58,20 @@ Feature: Basic Roundabout
            | bkheb | roundabout | yes    |
 
         When I route I should get
-           | waypoints | route       | turns                           |
-           | a,c       | abc,abc,abc | depart,roundabout-exit-1,arrive |
-           | a,l       | abc,jkl,jkl | depart,roundabout-exit-2,arrive |
-           | a,i       | abc,ghi,ghi | depart,roundabout-exit-3,arrive |
-           | a,f       | abc,def,def | depart,roundabout-exit-4,arrive |
-           | d,f       | def,def,def | depart,roundabout-exit-1,arrive |
-           | d,c       | def,abc,abc | depart,roundabout-exit-2,arrive |
-           | d,l       | def,jkl,jkl | depart,roundabout-exit-3,arrive |
-           | d,i       | def,ghi,ghi | depart,roundabout-exit-4,arrive |
-           | g,i       | ghi,ghi,ghi | depart,roundabout-exit-1,arrive |
-           | g,f       | ghi,def,def | depart,roundabout-exit-2,arrive |
-           | g,c       | ghi,abc,abc | depart,roundabout-exit-3,arrive |
-           | g,l       | ghi,jkl,jkl | depart,roundabout-exit-4,arrive |
-           | j,l       | jkl,jkl,jkl | depart,roundabout-exit-1,arrive |
-           | j,i       | jkl,ghi,ghi | depart,roundabout-exit-2,arrive |
-           | j,f       | jkl,def,def | depart,roundabout-exit-3,arrive |
-           | j,c       | jkl,abc,abc | depart,roundabout-exit-4,arrive |
+           | waypoints | route           | turns                                                    |
+           | a,c       | abc,abc,abc     | depart,exit roundabout right,arrive                      |
+           | a,l       | abc,jkl,jkl,jkl | depart,roundabout-exit-2,exit roundabout straight,arrive |
+           | a,i       | abc,ghi,ghi,ghi | depart,roundabout-exit-3,exit roundabout straight,arrive |
+           | a,f       | abc,def,def,def | depart,roundabout-exit-4,exit roundabout straight,arrive |
+           | d,f       | def,def,def     | depart,exit roundabout right,arrive                      |
+           | d,c       | def,abc,abc,abc | depart,roundabout-exit-2,exit roundabout straight,arrive |
+           | d,l       | def,jkl,jkl,jkl | depart,roundabout-exit-3,exit roundabout straight,arrive |
+           | d,i       | def,ghi,ghi,ghi | depart,roundabout-exit-4,exit roundabout straight,arrive |
+           | g,i       | ghi,ghi,ghi     | depart,exit roundabout right,arrive                      |
+           | g,f       | ghi,def,def,def | depart,roundabout-exit-2,exit roundabout straight,arrive |
+           | g,c       | ghi,abc,abc,abc | depart,roundabout-exit-3,exit roundabout straight,arrive |
+           | g,l       | ghi,jkl,jkl,jkl | depart,roundabout-exit-4,exit roundabout straight,arrive |
+           | j,l       | jkl,jkl,jkl     | depart,exit roundabout right,arrive                      |
+           | j,i       | jkl,ghi,ghi,ghi | depart,roundabout-exit-2,exit roundabout straight,arrive |
+           | j,f       | jkl,def,def,def | depart,roundabout-exit-3,exit roundabout straight,arrive |
+           | j,c       | jkl,abc,abc,abc | depart,roundabout-exit-4,exit roundabout straight,arrive |

features/guidance/roundabout-left-sided.feature

@@ -52,7 +52,7 @@ Feature: Basic Roundabout
            | 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 |
+           | waypoints | route           | turns                                                    |
+           | c,a       | cba,cba,cba     | depart,exit roundabout left,arrive                       |
+           | l,a       | lkj,cba,cba,cba | depart,roundabout-exit-2,exit roundabout straight,arrive |
+           | i,a       | ihg,cba,cba,cba | depart,roundabout-exit-3,exit roundabout straight,arrive |

features/guidance/roundabout-turn-bike.feature

@@ -5,39 +5,6 @@ Feature: Basic Roundabout
         Given the profile "bicycle"
         Given a grid size of 10 meters
 
-    Scenario: Enter and Exit
-        Given the node map
-            """
-                a
-                b
-            h g   c d
-                e
-                f
-            """
-
-       And the ways
-            | nodes  | junction   |
-            | ab     |            |
-            | cd     |            |
-            | ef     |            |
-            | gh     |            |
-            | bgecb  | roundabout |
-
-       When I route I should get
-           | waypoints | route    | turns                                         |
-           | a,d       | ab,cd,cd | depart,roundabout turn left exit-3,arrive     |
-           | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive |
-           | a,h       | ab,gh,gh | depart,roundabout turn right exit-1,arrive    |
-           | d,f       | cd,ef,ef | depart,roundabout turn left exit-3,arrive     |
-           | d,h       | cd,gh,gh | depart,roundabout turn straight exit-2,arrive |
-           | d,a       | cd,ab,ab | depart,roundabout turn right exit-1,arrive    |
-           | f,h       | ef,gh,gh | depart,roundabout turn left exit-3,arrive     |
-           | f,a       | ef,ab,ab | depart,roundabout turn straight exit-2,arrive |
-           | f,d       | ef,cd,cd | depart,roundabout turn right exit-1,arrive    |
-           | h,a       | gh,ab,ab | depart,roundabout turn left exit-3,arrive     |
-           | h,d       | gh,cd,cd | depart,roundabout turn straight exit-2,arrive |
-           | h,f       | gh,ef,ef | depart,roundabout turn right exit-1,arrive    |
-
     # https://www.openstreetmap.org/way/223225602
     Scenario: Enter and Exit with changing mode
         Given the node map
@@ -58,16 +25,16 @@ Feature: Basic Roundabout
             | bgecb | roundabout | residential |
 
        When I route I should get
-           | waypoints | route          | turns                                                              |
-           | a,d       | ab,cd,cd       | depart,roundabout turn left exit-1,arrive                          |
-           | a,f       | ab,ef,ef,ef    | depart,roundabout turn left exit-1,notification right,arrive       |
-           | a,h       | ab,bgecb,gh,gh | depart,roundabout turn right exit-1,notification right,arrive      |
-           | d,f       | cd,ef,ef,ef    | depart,roundabout turn sharp left exit-2,notification right,arrive |
-           | d,h       | cd,gh,gh,gh    | depart,roundabout turn left exit-2,notification right,arrive       |
-           | d,a       | cd,ab,ab       | depart,roundabout turn right exit-1,arrive                         |
-           | f,h       | ef,gh,gh,gh    | depart,roundabout turn sharp left exit-3,notification right,arrive |
-           | f,a       | ef,ab,ab       | depart,roundabout turn straight exit-2,arrive                      |
-           | f,d       | ef,cd,cd       | depart,roundabout turn right exit-1,arrive                         |
-           | h,a       | gh,ab,ab       | depart,roundabout turn left exit-2,arrive                          |
-           | h,d       | gh,cd,cd       | depart,roundabout turn straight exit-1,arrive                      |
-           | h,f       | gh,bgecb,ef,ef | depart,roundabout turn right exit-1,notification right,arrive      |
+           | waypoints | route       | turns                                                               |
+		   | a,d       | ab,cd,cd    | depart,roundabout turn left exit-1,arrive 	                       |
+		   | a,f       | ab,ef,ef,ef | depart,roundabout turn straight exit-1,exit roundabout right,arrive |
+		   | a,h       | ab,gh,gh,gh | depart,roundabout turn right exit-1,exit roundabout right,arrive    |
+		   | d,f       | cd,ef,ef,ef | depart,roundabout turn left exit-2,exit roundabout right,arrive 	   |
+		   | d,h       | cd,gh,gh,gh | depart,roundabout turn straight exit-2,exit roundabout right,arrive |
+		   | d,a       | cd,ab,ab    | depart,roundabout turn right exit-1,arrive 	                       |
+		   | f,h       | ef,gh,gh,gh | depart,roundabout turn left exit-3,exit roundabout right,arrive 	   |
+		   | f,a       | ef,ab,ab    | depart,roundabout turn straight exit-2,arrive                       |
+		   | f,d       | ef,cd,cd    | depart,roundabout turn right exit-1,arrive 	                       |
+		   | h,a       | gh,ab,ab    | depart,roundabout turn left exit-2,arrive 	                       |
+		   | h,d       | gh,cd,cd    | depart,roundabout turn straight exit-1,arrive                       |
+		   | h,f       | gh,ef,ef,ef | depart,roundabout turn right exit-1,exit roundabout right,arrive    |

features/guidance/roundabout-turn.feature

@@ -25,18 +25,18 @@ Feature: Basic Roundabout
 
        When I route I should get
            | waypoints | route    | turns                                         |
-           | a,d       | ab,cd,cd | depart,roundabout turn left exit-3,arrive     |
-           | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive |
-           | a,h       | ab,gh,gh | depart,roundabout turn right exit-1,arrive    |
-           | d,f       | cd,ef,ef | depart,roundabout turn left exit-3,arrive     |
-           | d,h       | cd,gh,gh | depart,roundabout turn straight exit-2,arrive |
-           | d,a       | cd,ab,ab | depart,roundabout turn right exit-1,arrive    |
-           | f,h       | ef,gh,gh | depart,roundabout turn left exit-3,arrive     |
-           | f,a       | ef,ab,ab | depart,roundabout turn straight exit-2,arrive |
-           | f,d       | ef,cd,cd | depart,roundabout turn right exit-1,arrive    |
-           | h,a       | gh,ab,ab | depart,roundabout turn left exit-3,arrive     |
-           | h,d       | gh,cd,cd | depart,roundabout turn straight exit-2,arrive |
-           | h,f       | gh,ef,ef | depart,roundabout turn right exit-1,arrive    |
+  		   | a,d       | ab,cd,cd | depart,roundabout turn left exit-3,arrive 	  |
+		   | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive |
+		   | a,h       | ab,gh,gh | depart,roundabout turn right exit-1,arrive 	  |
+		   | d,f       | cd,ef,ef | depart,roundabout turn left exit-3,arrive 	  |
+		   | d,h       | cd,gh,gh | depart,roundabout turn straight exit-2,arrive |
+		   | d,a       | cd,ab,ab | depart,roundabout turn right exit-1,arrive    |
+		   | f,h       | ef,gh,gh | depart,roundabout turn left exit-3,arrive 	  |
+		   | f,a       | ef,ab,ab | depart,roundabout turn straight exit-2,arrive |
+		   | f,d       | ef,cd,cd | depart,roundabout turn right exit-1,arrive 	  |
+		   | h,a       | gh,ab,ab | depart,roundabout turn left exit-3,arrive 	  |
+		   | h,d       | gh,cd,cd | depart,roundabout turn straight exit-2,arrive |
+		   | h,f       | gh,ef,ef | depart,roundabout turn right exit-1,arrive 	  |
 
     Scenario: Enter and Exit - Rotated
         Given the node map
@@ -56,21 +56,21 @@ Feature: Basic Roundabout
             | bgecb  | roundabout |
 
        When I route I should get
-           | waypoints | route    | turns                                         |
-           | a,d       | ab,cd,cd | depart,roundabout turn left exit-3,arrive     |
-           | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive |
-           | a,h       | ab,gh,gh | depart,roundabout turn right exit-1,arrive    |
-           | d,f       | cd,ef,ef | depart,roundabout turn left exit-3,arrive     |
-           | d,h       | cd,gh,gh | depart,roundabout turn straight exit-2,arrive |
-           | d,a       | cd,ab,ab | depart,roundabout turn right exit-1,arrive    |
-           | f,h       | ef,gh,gh | depart,roundabout turn left exit-3,arrive     |
-           | f,a       | ef,ab,ab | depart,roundabout turn straight exit-2,arrive |
-           | f,d       | ef,cd,cd | depart,roundabout turn right exit-1,arrive    |
-           | h,a       | gh,ab,ab | depart,roundabout turn left exit-3,arrive     |
-           | h,d       | gh,cd,cd | depart,roundabout turn straight exit-2,arrive |
-           | h,f       | gh,ef,ef | depart,roundabout turn right exit-1,arrive    |
+           | waypoints | route    | turns                                     	  |
+		   | a,d       | ab,cd,cd | depart,roundabout turn left exit-3,arrive 	  |
+  		   | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive |
+		   | a,h       | ab,gh,gh | depart,roundabout turn right exit-1,arrive 	  |
+		   | d,f       | cd,ef,ef | depart,roundabout turn left exit-3,arrive 	  |
+		   | d,h       | cd,gh,gh | depart,roundabout turn straight exit-2,arrive |
+		   | d,a       | cd,ab,ab | depart,roundabout turn right exit-1,arrive 	  |
+		   | f,h       | ef,gh,gh | depart,roundabout turn left exit-3,arrive 	  |
+		   | f,a       | ef,ab,ab | depart,roundabout turn straight exit-2,arrive |
+		   | f,d       | ef,cd,cd | depart,roundabout turn right exit-1,arrive 	  |
+		   | h,a       | gh,ab,ab | depart,roundabout turn left exit-3,arrive 	  |
+		   | h,d       | gh,cd,cd | depart,roundabout turn straight exit-2,arrive |
+		   | h,f       | gh,ef,ef | depart,roundabout turn right exit-1,arrive 	  |
 
-    Scenario: Only Enter
+	Scenario: Only Enter
         Given the node map
             """
                 a
@@ -122,19 +122,19 @@ Feature: Basic Roundabout
             | bcegb  | roundabout |
 
        When I route I should get
-           | waypoints | route       | turns                           |
-           | b,d       | bcegb,cd,cd | depart,roundabout-exit-1,arrive |
-           | b,f       | bcegb,ef,ef | depart,roundabout-exit-2,arrive |
-           | b,h       | bcegb,gh,gh | depart,roundabout-exit-3,arrive |
-           | c,f       | bcegb,ef,ef | depart,roundabout-exit-1,arrive |
-           | c,h       | bcegb,gh,gh | depart,roundabout-exit-2,arrive |
-           | c,a       | bcegb,ab,ab | depart,roundabout-exit-3,arrive |
-           | e,h       | bcegb,gh,gh | depart,roundabout-exit-1,arrive |
-           | e,a       | bcegb,ab,ab | depart,roundabout-exit-2,arrive |
-           | e,d       | bcegb,cd,cd | depart,roundabout-exit-3,arrive |
-           | g,a       | bcegb,ab,ab | depart,roundabout-exit-1,arrive |
-           | g,d       | bcegb,cd,cd | depart,roundabout-exit-2,arrive |
-           | g,f       | bcegb,ef,ef | depart,roundabout-exit-3,arrive |
+           | waypoints | route       | turns       			           	   |
+		   | b,d       | bcegb,cd,cd | depart,exit roundabout right,arrive |
+		   | b,f       | bcegb,ef,ef | depart,exit roundabout right,arrive |
+		   | b,h       | bcegb,gh,gh | depart,exit roundabout right,arrive |
+		   | c,f       | bcegb,ef,ef | depart,exit roundabout right,arrive |
+		   | c,h       | bcegb,gh,gh | depart,exit roundabout right,arrive |
+		   | c,a       | bcegb,ab,ab | depart,exit roundabout right,arrive |
+		   | e,h       | bcegb,gh,gh | depart,exit roundabout right,arrive |
+		   | e,a       | bcegb,ab,ab | depart,exit roundabout right,arrive |
+		   | e,d       | bcegb,cd,cd | depart,exit roundabout right,arrive |
+		   | g,a       | bcegb,ab,ab | depart,exit roundabout right,arrive |
+		   | g,d       | bcegb,cd,cd | depart,exit roundabout right,arrive |
+		   | g,f       | bcegb,ef,ef | depart,exit roundabout right,arrive |
       #phantom node snapping can result in a full round-trip here, therefore we cannot test b->a and the other direct exits
 
     Scenario: Drive Around
@@ -189,23 +189,23 @@ Feature: Basic Roundabout
            | bkheb | roundabout | yes    |
 
         When I route I should get
-           | waypoints | route       | turns                           |
-           | a,c       | abc,abc,abc | depart,roundabout-exit-1,arrive |
-           | a,l       | abc,jkl,jkl | depart,roundabout-exit-2,arrive |
-           | a,i       | abc,ghi,ghi | depart,roundabout-exit-3,arrive |
-           | a,f       | abc,def,def | depart,roundabout-exit-4,arrive |
-           | d,f       | def,def,def | depart,roundabout-exit-1,arrive |
-           | d,c       | def,abc,abc | depart,roundabout-exit-2,arrive |
-           | d,l       | def,jkl,jkl | depart,roundabout-exit-3,arrive |
-           | d,i       | def,ghi,ghi | depart,roundabout-exit-4,arrive |
-           | g,i       | ghi,ghi,ghi | depart,roundabout-exit-1,arrive |
-           | g,f       | ghi,def,def | depart,roundabout-exit-2,arrive |
-           | g,c       | ghi,abc,abc | depart,roundabout-exit-3,arrive |
-           | g,l       | ghi,jkl,jkl | depart,roundabout-exit-4,arrive |
-           | j,l       | jkl,jkl,jkl | depart,roundabout-exit-1,arrive |
-           | j,i       | jkl,ghi,ghi | depart,roundabout-exit-2,arrive |
-           | j,f       | jkl,def,def | depart,roundabout-exit-3,arrive |
-           | j,c       | jkl,abc,abc | depart,roundabout-exit-4,arrive |
+           | waypoints | route     		 | turns                           							|
+		   | a,c       | abc,abc,abc	 | depart,exit roundabout right,arrive 					    |
+		   | a,l       | abc,jkl,jkl,jkl | depart,roundabout-exit-2,exit roundabout straight,arrive |
+		   | a,i       | abc,ghi,ghi,ghi | depart,roundabout-exit-3,exit roundabout straight,arrive |
+		   | a,f       | abc,def,def,def | depart,roundabout-exit-4,exit roundabout straight,arrive |
+		   | d,f       | def,def,def	 | depart,exit roundabout right,arrive 					    |
+		   | d,c       | def,abc,abc,abc | depart,roundabout-exit-2,exit roundabout straight,arrive |
+		   | d,l       | def,jkl,jkl,jkl | depart,roundabout-exit-3,exit roundabout straight,arrive |
+		   | d,i       | def,ghi,ghi,ghi | depart,roundabout-exit-4,exit roundabout straight,arrive |
+		   | g,i       | ghi,ghi,ghi	 | depart,exit roundabout right,arrive 					    |
+		   | g,f       | ghi,def,def,def | depart,roundabout-exit-2,exit roundabout straight,arrive |
+		   | g,c       | ghi,abc,abc,abc | depart,roundabout-exit-3,exit roundabout straight,arrive |
+		   | g,l       | ghi,jkl,jkl,jkl | depart,roundabout-exit-4,exit roundabout straight,arrive |
+		   | j,l       | jkl,jkl,jkl	 | depart,exit roundabout right,arrive					    |
+		   | j,i       | jkl,ghi,ghi,ghi | depart,roundabout-exit-2,exit roundabout straight,arrive |
+		   | j,f       | jkl,def,def,def | depart,roundabout-exit-3,exit roundabout straight,arrive |
+		   | j,c       | jkl,abc,abc,abc | depart,roundabout-exit-4,exit roundabout straight,arrive |
 
     Scenario: Segregated roads - Not an intersection
         Given the node map
@@ -226,23 +226,23 @@ Feature: Basic Roundabout
            | bkheb | roundabout | yes    |
 
         When I route I should get
-           | waypoints | route       | turns                           |
-           | a,c       | abc,abc,abc | depart,roundabout-exit-4,arrive |
-           | a,l       | abc,jkl,jkl | depart,roundabout-exit-1,arrive |
-           | a,i       | abc,ghi,ghi | depart,roundabout-exit-2,arrive |
-           | a,f       | abc,def,def | depart,roundabout-exit-3,arrive |
-           | d,f       | def,def,def | depart,roundabout-exit-4,arrive |
-           | d,c       | def,abc,abc | depart,roundabout-exit-1,arrive |
-           | d,l       | def,jkl,jkl | depart,roundabout-exit-2,arrive |
-           | d,i       | def,ghi,ghi | depart,roundabout-exit-3,arrive |
-           | g,i       | ghi,ghi,ghi | depart,roundabout-exit-4,arrive |
-           | g,f       | ghi,def,def | depart,roundabout-exit-1,arrive |
-           | g,c       | ghi,abc,abc | depart,roundabout-exit-2,arrive |
-           | g,l       | ghi,jkl,jkl | depart,roundabout-exit-3,arrive |
-           | j,l       | jkl,jkl,jkl | depart,roundabout-exit-4,arrive |
-           | j,i       | jkl,ghi,ghi | depart,roundabout-exit-1,arrive |
-           | j,f       | jkl,def,def | depart,roundabout-exit-2,arrive |
-           | j,c       | jkl,abc,abc | depart,roundabout-exit-3,arrive |
+           | waypoints | route       	 | turns                           						 |
+		   | a,c       | abc,abc,abc,abc | depart,roundabout-exit-4,exit roundabout right,arrive |
+		   | a,l       | abc,jkl,jkl,jkl | depart,roundabout-exit-1,exit roundabout right,arrive |
+		   | a,i       | abc,ghi,ghi,ghi | depart,roundabout-exit-2,exit roundabout right,arrive |
+		   | a,f       | abc,def,def,def | depart,roundabout-exit-3,exit roundabout right,arrive |
+		   | d,f       | def,def,def,def | depart,roundabout-exit-4,exit roundabout right,arrive |
+		   | d,c       | def,abc,abc,abc | depart,roundabout-exit-1,exit roundabout right,arrive |
+		   | d,l       | def,jkl,jkl,jkl | depart,roundabout-exit-2,exit roundabout right,arrive |
+		   | d,i       | def,ghi,ghi,ghi | depart,roundabout-exit-3,exit roundabout right,arrive |
+		   | g,i       | ghi,ghi,ghi,ghi | depart,roundabout-exit-4,exit roundabout right,arrive |
+		   | g,f       | ghi,def,def,def | depart,roundabout-exit-1,exit roundabout right,arrive |
+		   | g,c       | ghi,abc,abc,abc | depart,roundabout-exit-2,exit roundabout right,arrive |
+		   | g,l       | ghi,jkl,jkl,jkl | depart,roundabout-exit-3,exit roundabout right,arrive |
+		   | j,l       | jkl,jkl,jkl,jkl | depart,roundabout-exit-4,exit roundabout right,arrive |
+		   | j,i       | jkl,ghi,ghi,ghi | depart,roundabout-exit-1,exit roundabout right,arrive |
+		   | j,f       | jkl,def,def,def | depart,roundabout-exit-2,exit roundabout right,arrive |
+		   | j,c       | jkl,abc,abc,abc | depart,roundabout-exit-3,exit roundabout right,arrive |
 
        Scenario: Collinear in X
         Given the node map
@@ -259,9 +259,9 @@ Feature: Basic Roundabout
             | df    |            |
 
         When I route I should get
-            | waypoints | route    | turns                                         |
-            | a,e       | ab,ce,ce | depart,roundabout turn right exit-1,arrive    |
-            | a,f       | ab,df,df | depart,roundabout turn straight exit-2,arrive |
+            | waypoints | route    | turns                                     	  |
+     		| a,e       | ab,ce,ce | depart,roundabout turn right exit-1,arrive 	  |
+     		| a,f       | ab,df,df | depart,roundabout turn straight exit-2,arrive |
 
        Scenario: Collinear in Y
         Given the node map
@@ -281,7 +281,7 @@ Feature: Basic Roundabout
             | df    |            |
 
         When I route I should get
-            | waypoints | route    | turns                                         |
+            | waypoints | route    | turns                                      	  |
             | a,e       | ab,ce,ce | depart,roundabout turn right exit-1,arrive    |
             | a,f       | ab,df,df | depart,roundabout turn straight exit-2,arrive |
 
@@ -302,7 +302,7 @@ Feature: Basic Roundabout
             | df    |            |
 
         When I route I should get
-            | waypoints | route    | turns                                         |
+            | waypoints | route    | turns                             		  	   |
             | a,e       | ab,ce,ce | depart,roundabout turn straight exit-1,arrive |
             | a,f       | ab,df,df | depart,roundabout turn left exit-2,arrive     |
 
@@ -323,7 +323,7 @@ Feature: Basic Roundabout
             | cf    |            |
 
         When I route I should get
-            | waypoints | route    | turns                                         |
+            | waypoints | route    | turns                            			  |
             | a,e       | ad,be,be | depart,roundabout turn straight exit-1,arrive |
             | a,f       | ad,cf,cf | depart,roundabout turn left exit-2,arrive     |
 
@@ -344,7 +344,7 @@ Feature: Basic Roundabout
             | bf    |            |
 
         When I route I should get
-            | waypoints | route    | turns                                         |
+            | waypoints | route    | turns                                		   |
             | a,e       | ac,de,de | depart,roundabout turn straight exit-1,arrive |
             | a,f       | ac,bf,bf | depart,roundabout turn left exit-2,arrive     |
 
@@ -368,19 +368,19 @@ Feature: Basic Roundabout
             | bigecb | roundabout |
 
        When I route I should get
-           | waypoints | route    | turns                           |
-           | a,d       | ab,cd,cd | depart,roundabout-exit-4,arrive |
-           | a,f       | ab,ef,ef | depart,roundabout-exit-3,arrive |
-           | a,h       | ab,gh,gh | depart,roundabout-exit-2,arrive |
-           | d,f       | cd,ef,ef | depart,roundabout-exit-4,arrive |
-           | d,h       | cd,gh,gh | depart,roundabout-exit-3,arrive |
-           | d,a       | cd,ab,ab | depart,roundabout-exit-1,arrive |
-           | f,h       | ef,gh,gh | depart,roundabout-exit-4,arrive |
-           | f,a       | ef,ab,ab | depart,roundabout-exit-2,arrive |
-           | f,d       | ef,cd,cd | depart,roundabout-exit-1,arrive |
-           | h,a       | gh,ab,ab | depart,roundabout-exit-3,arrive |
-           | h,d       | gh,cd,cd | depart,roundabout-exit-2,arrive |
-           | h,f       | gh,ef,ef | depart,roundabout-exit-1,arrive |
+           | waypoints | route    	 | turns                           						 |
+		   | a,d       | ab,cd,cd,cd | depart,roundabout-exit-4,exit roundabout right,arrive |
+		   | a,f       | ab,ef,ef,ef | depart,roundabout-exit-3,exit roundabout right,arrive |
+ 		   | a,h       | ab,gh,gh,gh | depart,roundabout-exit-2,exit roundabout right,arrive |
+		   | d,f       | cd,ef,ef,ef | depart,roundabout-exit-4,exit roundabout right,arrive |
+		   | d,h       | cd,gh,gh,gh | depart,roundabout-exit-3,exit roundabout right,arrive |
+		   | d,a       | cd,ab,ab,ab | depart,roundabout-exit-1,exit roundabout right,arrive |
+		   | f,h       | ef,gh,gh,gh | depart,roundabout-exit-4,exit roundabout right,arrive |
+		   | f,a       | ef,ab,ab,ab | depart,roundabout-exit-2,exit roundabout right,arrive |
+		   | f,d       | ef,cd,cd,cd | depart,roundabout-exit-1,exit roundabout right,arrive |
+		   | h,a       | gh,ab,ab,ab | depart,roundabout-exit-3,exit roundabout right,arrive |
+		   | h,d       | gh,cd,cd,cd | depart,roundabout-exit-2,exit roundabout right,arrive |
+		   | h,f       | gh,ef,ef,ef | depart,roundabout-exit-1,exit roundabout right,arrive |
 
     Scenario: Enter and Exit -- Non-Distinct
         Given the node map
@@ -401,19 +401,19 @@ Feature: Basic Roundabout
             | bgecb | roundabout |
 
        When I route I should get
-           | waypoints | route    | turns                           |
-           | a,d       | ab,cd,cd | depart,roundabout-exit-3,arrive |
-           | a,f       | ab,ef,ef | depart,roundabout-exit-2,arrive |
-           | a,h       | ab,gh,gh | depart,roundabout-exit-1,arrive |
-           | d,f       | cd,ef,ef | depart,roundabout-exit-3,arrive |
-           | d,h       | cd,gh,gh | depart,roundabout-exit-2,arrive |
-           | d,a       | cd,ab,ab | depart,roundabout-exit-1,arrive |
-           | f,h       | ef,gh,gh | depart,roundabout-exit-3,arrive |
-           | f,a       | ef,ab,ab | depart,roundabout-exit-2,arrive |
-           | f,d       | ef,cd,cd | depart,roundabout-exit-1,arrive |
-           | h,a       | gh,ab,ab | depart,roundabout-exit-3,arrive |
-           | h,d       | gh,cd,cd | depart,roundabout-exit-2,arrive |
-           | h,f       | gh,ef,ef | depart,roundabout-exit-1,arrive |
+           | waypoints | route    	 | turns                           							|
+		   | a,d       | ab,cd,cd,cd | depart,roundabout-exit-3,exit roundabout right,arrive 	|
+		   | a,f       | ab,ef,ef,ef | depart,roundabout-exit-2,exit roundabout right,arrive 	|
+		   | a,h       | ab,gh,gh,gh | depart,roundabout-exit-1,exit roundabout straight,arrive |
+		   | d,f       | cd,ef,ef,ef | depart,roundabout-exit-3,exit roundabout right,arrive 	|
+		   | d,h       | cd,gh,gh,gh | depart,roundabout-exit-2,exit roundabout straight,arrive |
+		   | d,a       | cd,ab,ab,ab | depart,roundabout-exit-1,exit roundabout right,arrive 	|
+		   | f,h       | ef,gh,gh,gh | depart,roundabout-exit-3,exit roundabout straight,arrive |
+		   | f,a       | ef,ab,ab,ab | depart,roundabout-exit-2,exit roundabout right,arrive 	|
+		   | f,d       | ef,cd,cd,cd | depart,roundabout-exit-1,exit roundabout right,arrive 	|
+		   | h,a       | gh,ab,ab,ab | depart,roundabout-exit-3,exit roundabout right,arrive 	|
+		   | h,d       | gh,cd,cd,cd | depart,roundabout-exit-2,exit roundabout right,arrive 	|
+		   | h,f       | gh,ef,ef,ef | depart,roundabout-exit-1,exit roundabout right,arrive 	|
 
     Scenario: Enter and Exit -- Bearing
         Given the node map
@@ -435,9 +435,9 @@ Feature: Basic Roundabout
 
        When I route I should get
            | waypoints | route    | turns                                         | bearing                |
-           | a,d       | ab,cd,cd | depart,roundabout turn left exit-3,arrive     | 0->180,180->225,90->0  |
-           | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive | 0->180,180->225,180->0 |
-           | a,h       | ab,gh,gh | depart,roundabout turn right exit-1,arrive    | 0->180,180->225,270->0 |
+		   | a,d       | ab,cd,cd | depart,roundabout turn left exit-3,arrive 	  | 0->180,180->225,90->0  |
+    	   | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive | 0->180,180->225,180->0 |
+     	   | a,h       | ab,gh,gh | depart,roundabout turn right exit-1,arrive 	  | 0->180,180->225,270->0 |
 
     Scenario: Enter and Exit - Bearings
         Given the node map
@@ -461,9 +461,9 @@ Feature: Basic Roundabout
 
        When I route I should get
            | waypoints | route    | turns                                         | bearing                |
-           | a,d       | ab,cd,cd | depart,roundabout turn left exit-3,arrive     | 0->180,180->270,90->0  |
-           | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive | 0->180,180->270,180->0 |
-           | a,h       | ab,gh,gh | depart,roundabout turn right exit-1,arrive    | 0->180,180->270,270->0 |
+		   | a,d       | ab,cd,cd | depart,roundabout turn left exit-3,arrive 	  | 0->180,180->270,90->0  |
+      	   | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive | 0->180,180->270,180->0 |
+     	   | a,h       | ab,gh,gh | depart,roundabout turn right exit-1,arrive 	  | 0->180,180->270,270->0 |
 
     Scenario: Large radius Roundabout Intersection and ways modelled out: East Mission St, North 7th St
     # http://www.openstreetmap.org/way/348812150
@@ -495,18 +495,18 @@ Feature: Basic Roundabout
 
        When I route I should get
            | waypoints | route                                           | turns                                         |
-           | a,e       | North 7th St,East Mission St,East Mission St    | depart,roundabout turn right exit-1,arrive    |
-           | a,h       | North 7th St,North 7th St,North 7th St          | depart,roundabout turn straight exit-2,arrive |
-           | a,l       | North 7th St,East Mission St,East Mission St    | depart,roundabout turn left exit-3,arrive     |
-           | h,l       | North 7th St,East Mission St,East Mission St    | depart,roundabout turn right exit-1,arrive    |
-           | h,a       | North 7th St,North 7th St,North 7th St          | depart,roundabout turn straight exit-2,arrive |
-           | h,e       | North 7th St,East Mission St,East Mission St    | depart,roundabout turn left exit-3,arrive     |
-           | e,h       | East Mission St,North 7th St,North 7th St       | depart,roundabout turn right exit-1,arrive    |
-           | e,l       | East Mission St,East Mission St,East Mission St | depart,roundabout turn straight exit-2,arrive |
-           | e,a       | East Mission St,North 7th St,North 7th St       | depart,roundabout turn left exit-3,arrive     |
-           | l,a       | East Mission St,North 7th St,North 7th St       | depart,roundabout turn right exit-1,arrive    |
-           | l,e       | East Mission St,East Mission St,East Mission St | depart,roundabout turn straight exit-2,arrive |
-           | l,h       | East Mission St,North 7th St,North 7th St       | depart,roundabout turn left exit-3,arrive     |
+		   | a,e       | North 7th St,East Mission St,East Mission St 	 | depart,roundabout turn right exit-1,arrive 	 |
+		   | a,h       | North 7th St,North 7th St,North 7th St 		 | depart,roundabout turn straight exit-2,arrive |
+		   | a,l       | North 7th St,East Mission St,East Mission St 	 | depart,roundabout turn left exit-3,arrive 	 |
+		   | h,l       | North 7th St,East Mission St,East Mission St 	 | depart,roundabout turn right exit-1,arrive 	 |
+		   | h,a       | North 7th St,North 7th St,North 7th St 		 | depart,roundabout turn straight exit-2,arrive |
+		   | h,e       | North 7th St,East Mission St,East Mission St 	 | depart,roundabout turn left exit-3,arrive 	 |
+		   | e,h       | East Mission St,North 7th St,North 7th St 		 | depart,roundabout turn right exit-1,arrive    |
+		   | e,l       | East Mission St,East Mission St,East Mission St | depart,roundabout turn straight exit-2,arrive |
+		   | e,a       | East Mission St,North 7th St,North 7th St 		 | depart,roundabout turn left exit-3,arrive 	 |
+		   | l,a       | East Mission St,North 7th St,North 7th St 		 | depart,roundabout turn right exit-1,arrive 	 |
+		   | l,e       | East Mission St,East Mission St,East Mission St | depart,roundabout turn straight exit-2,arrive |
+		   | l,h       | East Mission St,North 7th St,North 7th St 		 | depart,roundabout turn left exit-3,arrive 	 |
 
     Scenario: Enter and Exit - Traffic Signals
         Given the node map
@@ -534,19 +534,19 @@ Feature: Basic Roundabout
             | bigjekclb | roundabout |
 
        When I route I should get
-           | waypoints | route    | turns                                         |
-           | a,d       | ab,cd,cd | depart,roundabout turn left exit-3,arrive     |
-           | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive |
-           | a,h       | ab,gh,gh | depart,roundabout turn right exit-1,arrive    |
-           | d,f       | cd,ef,ef | depart,roundabout turn left exit-3,arrive     |
-           | d,h       | cd,gh,gh | depart,roundabout turn straight exit-2,arrive |
-           | d,a       | cd,ab,ab | depart,roundabout turn right exit-1,arrive    |
-           | f,h       | ef,gh,gh | depart,roundabout turn left exit-3,arrive     |
-           | f,a       | ef,ab,ab | depart,roundabout turn straight exit-2,arrive |
-           | f,d       | ef,cd,cd | depart,roundabout turn right exit-1,arrive    |
-           | h,a       | gh,ab,ab | depart,roundabout turn left exit-3,arrive     |
-           | h,d       | gh,cd,cd | depart,roundabout turn straight exit-2,arrive |
-           | h,f       | gh,ef,ef | depart,roundabout turn right exit-1,arrive    |
+           | waypoints | route 	  | turns                                         |
+		   | a,d       | ab,cd,cd | depart,roundabout turn left exit-3,arrive 	 |
+		   | a,f       | ab,ef,ef | depart,roundabout turn straight exit-2,arrive |
+		   | a,h       | ab,gh,gh | depart,roundabout turn right exit-1,arrive 	 |
+		   | d,f       | cd,ef,ef | depart,roundabout turn left exit-3,arrive 	 |
+		   | d,h       | cd,gh,gh | depart,roundabout turn straight exit-2,arrive |
+		   | d,a       | cd,ab,ab | depart,roundabout turn right exit-1,arrive 	 |
+		   | f,h       | ef,gh,gh | depart,roundabout turn left exit-3,arrive 	 |
+		   | f,a       | ef,ab,ab | depart,roundabout turn straight exit-2,arrive |
+		   | f,d       | ef,cd,cd | depart,roundabout turn right exit-1,arrive 	 |
+		   | h,a       | gh,ab,ab | depart,roundabout turn left exit-3,arrive 	 |
+		   | h,d       | gh,cd,cd | depart,roundabout turn straight exit-2,arrive |
+		   | h,f       | gh,ef,ef | depart,roundabout turn right exit-1,arrive 	 |
 
     #http://www.openstreetmap.org/#map=19/41.03275/-2.18990
     #at some point we probably want to recognise these situations and don't mention the roundabout at all here

features/guidance/roundabout.feature

@@ -57,10 +57,10 @@ Feature: Basic Roundabout
             | bcegb  | roundabout | primary |
 
         When I route I should get
-            | waypoints | route    | turns                           |
-            | a,d       | ab,cd,cd | depart,roundabout-exit-1,arrive |
-            | a,h       | ab,gh,gh | depart,roundabout-exit-2,arrive |
-            | a,f       | ab,ef,ef | depart,roundabout-exit-2,arrive |
+            | waypoints | route       | turns                                                    |
+            | a,d       | ab,cd,cd,cd | depart,roundabout-exit-1,exit roundabout right,arrive    |
+            | a,h       | ab,gh,gh,gh | depart,roundabout-exit-2,exit roundabout straight,arrive |
+            | a,f       | ab,ef,ef,ef | depart,roundabout-exit-2,exit roundabout right,arrive    |
 
     #2927
     Scenario: Only Roundabout
@@ -98,19 +98,19 @@ Feature: Basic Roundabout
             | bcegb  | roundabout |
 
        When I route I should get
-           | waypoints | route       | turns                           |
-           | b,d       | bcegb,cd,cd | depart,roundabout-exit-1,arrive |
-           | b,f       | bcegb,ef,ef | depart,roundabout-exit-2,arrive |
-           | b,h       | bcegb,gh,gh | depart,roundabout-exit-3,arrive |
-           | c,f       | bcegb,ef,ef | depart,roundabout-exit-1,arrive |
-           | c,h       | bcegb,gh,gh | depart,roundabout-exit-2,arrive |
-           | c,a       | bcegb,ab,ab | depart,roundabout-exit-3,arrive |
-           | e,h       | bcegb,gh,gh | depart,roundabout-exit-1,arrive |
-           | e,a       | bcegb,ab,ab | depart,roundabout-exit-2,arrive |
-           | e,d       | bcegb,cd,cd | depart,roundabout-exit-3,arrive |
-           | g,a       | bcegb,ab,ab | depart,roundabout-exit-1,arrive |
-           | g,d       | bcegb,cd,cd | depart,roundabout-exit-2,arrive |
-           | g,f       | bcegb,ef,ef | depart,roundabout-exit-3,arrive |
+           | waypoints | route       | turns                               |
+           | b,d       | bcegb,cd,cd | depart,exit roundabout right,arrive |
+           | b,f       | bcegb,ef,ef | depart,exit roundabout right,arrive |
+           | b,h       | bcegb,gh,gh | depart,exit roundabout right,arrive |
+           | c,f       | bcegb,ef,ef | depart,exit roundabout right,arrive |
+           | c,h       | bcegb,gh,gh | depart,exit roundabout right,arrive |
+           | c,a       | bcegb,ab,ab | depart,exit roundabout right,arrive |
+           | e,h       | bcegb,gh,gh | depart,exit roundabout right,arrive |
+           | e,a       | bcegb,ab,ab | depart,exit roundabout right,arrive |
+           | e,d       | bcegb,cd,cd | depart,exit roundabout right,arrive |
+           | g,a       | bcegb,ab,ab | depart,exit roundabout right,arrive |
+           | g,d       | bcegb,cd,cd | depart,exit roundabout right,arrive |
+           | g,f       | bcegb,ef,ef | depart,exit roundabout right,arrive |
       #phantom node snapping can result in a full round-trip here, therefore we cannot test b->a and the other direct exits
 
     Scenario: Drive Around
@@ -165,23 +165,23 @@ Feature: Basic Roundabout
            | bkheb | roundabout | yes    |
 
         When I route I should get
-           | waypoints | route       | turns                           |
-           | a,c       | abc,abc,abc | depart,roundabout-exit-1,arrive |
-           | a,l       | abc,jkl,jkl | depart,roundabout-exit-2,arrive |
-           | a,i       | abc,ghi,ghi | depart,roundabout-exit-3,arrive |
-           | a,f       | abc,def,def | depart,roundabout-exit-4,arrive |
-           | d,f       | def,def,def | depart,roundabout-exit-1,arrive |
-           | d,c       | def,abc,abc | depart,roundabout-exit-2,arrive |
-           | d,l       | def,jkl,jkl | depart,roundabout-exit-3,arrive |
-           | d,i       | def,ghi,ghi | depart,roundabout-exit-4,arrive |
-           | g,i       | ghi,ghi,ghi | depart,roundabout-exit-1,arrive |
-           | g,f       | ghi,def,def | depart,roundabout-exit-2,arrive |
-           | g,c       | ghi,abc,abc | depart,roundabout-exit-3,arrive |
-           | g,l       | ghi,jkl,jkl | depart,roundabout-exit-4,arrive |
-           | j,l       | jkl,jkl,jkl | depart,roundabout-exit-1,arrive |
-           | j,i       | jkl,ghi,ghi | depart,roundabout-exit-2,arrive |
-           | j,f       | jkl,def,def | depart,roundabout-exit-3,arrive |
-           | j,c       | jkl,abc,abc | depart,roundabout-exit-4,arrive |
+           | waypoints | route           | turns                                                    |
+           | a,c       | abc,abc,abc     | depart,exit roundabout right,arrive                      |
+           | a,l       | abc,jkl,jkl,jkl | depart,roundabout-exit-2,exit roundabout straight,arrive |
+           | a,i       | abc,ghi,ghi,ghi | depart,roundabout-exit-3,exit roundabout straight,arrive |
+           | a,f       | abc,def,def,def | depart,roundabout-exit-4,exit roundabout straight,arrive |
+           | d,f       | def,def,def     | depart,exit roundabout right,arrive                      |
+           | d,c       | def,abc,abc,abc | depart,roundabout-exit-2,exit roundabout straight,arrive |
+           | d,l       | def,jkl,jkl,jkl | depart,roundabout-exit-3,exit roundabout straight,arrive |
+           | d,i       | def,ghi,ghi,ghi | depart,roundabout-exit-4,exit roundabout straight,arrive |
+           | g,i       | ghi,ghi,ghi     | depart,exit roundabout right,arrive                      |
+           | g,f       | ghi,def,def,def | depart,roundabout-exit-2,exit roundabout straight,arrive |
+           | g,c       | ghi,abc,abc,abc | depart,roundabout-exit-3,exit roundabout straight,arrive |
+           | g,l       | ghi,jkl,jkl,jkl | depart,roundabout-exit-4,exit roundabout straight,arrive |
+           | j,l       | jkl,jkl,jkl     | depart,exit roundabout right,arrive                      |
+           | j,i       | jkl,ghi,ghi,ghi | depart,roundabout-exit-2,exit roundabout straight,arrive |
+           | j,f       | jkl,def,def,def | depart,roundabout-exit-3,exit roundabout straight,arrive |
+           | j,c       | jkl,abc,abc,abc | depart,roundabout-exit-4,exit roundabout straight,arrive |
 
     Scenario: Mixed Entry and Exit - segregated roads
         Given the node map
@@ -204,23 +204,23 @@ Feature: Basic Roundabout
            | bkheb | roundabout | yes    |
 
         When I route I should get
-           | waypoints | route       | turns                           |
-           | a,c       | abc,abc,abc | depart,roundabout-exit-4,arrive |
-           | a,l       | abc,jkl,jkl | depart,roundabout-exit-1,arrive |
-           | a,i       | abc,ghi,ghi | depart,roundabout-exit-2,arrive |
-           | a,f       | abc,def,def | depart,roundabout-exit-3,arrive |
-           | d,f       | def,def,def | depart,roundabout-exit-4,arrive |
-           | d,c       | def,abc,abc | depart,roundabout-exit-1,arrive |
-           | d,l       | def,jkl,jkl | depart,roundabout-exit-2,arrive |
-           | d,i       | def,ghi,ghi | depart,roundabout-exit-3,arrive |
-           | g,i       | ghi,ghi,ghi | depart,roundabout-exit-4,arrive |
-           | g,f       | ghi,def,def | depart,roundabout-exit-1,arrive |
-           | g,c       | ghi,abc,abc | depart,roundabout-exit-2,arrive |
-           | g,l       | ghi,jkl,jkl | depart,roundabout-exit-3,arrive |
-           | j,l       | jkl,jkl,jkl | depart,roundabout-exit-4,arrive |
-           | j,i       | jkl,ghi,ghi | depart,roundabout-exit-1,arrive |
-           | j,f       | jkl,def,def | depart,roundabout-exit-2,arrive |
-           | j,c       | jkl,abc,abc | depart,roundabout-exit-3,arrive |
+           | waypoints | route           | turns                                                 |
+           | a,c       | abc,abc,abc,abc | depart,roundabout-exit-4,exit roundabout right,arrive |
+           | a,l       | abc,jkl,jkl,jkl | depart,roundabout-exit-1,exit roundabout right,arrive |
+           | a,i       | abc,ghi,ghi,ghi | depart,roundabout-exit-2,exit roundabout right,arrive |
+           | a,f       | abc,def,def,def | depart,roundabout-exit-3,exit roundabout right,arrive |
+           | d,f       | def,def,def,def | depart,roundabout-exit-4,exit roundabout right,arrive |
+           | d,c       | def,abc,abc,abc | depart,roundabout-exit-1,exit roundabout right,arrive |
+           | d,l       | def,jkl,jkl,jkl | depart,roundabout-exit-2,exit roundabout right,arrive |
+           | d,i       | def,ghi,ghi,ghi | depart,roundabout-exit-3,exit roundabout right,arrive |
+           | g,i       | ghi,ghi,ghi,ghi | depart,roundabout-exit-4,exit roundabout right,arrive |
+           | g,f       | ghi,def,def,def | depart,roundabout-exit-1,exit roundabout right,arrive |
+           | g,c       | ghi,abc,abc,abc | depart,roundabout-exit-2,exit roundabout right,arrive |
+           | g,l       | ghi,jkl,jkl,jkl | depart,roundabout-exit-3,exit roundabout right,arrive |
+           | j,l       | jkl,jkl,jkl,jkl | depart,roundabout-exit-4,exit roundabout right,arrive |
+           | j,i       | jkl,ghi,ghi,ghi | depart,roundabout-exit-1,exit roundabout right,arrive |
+           | j,f       | jkl,def,def,def | depart,roundabout-exit-2,exit roundabout right,arrive |
+           | j,c       | jkl,abc,abc,abc | depart,roundabout-exit-3,exit roundabout right,arrive |
 
      Scenario: Mixed Entry and Exit - clockwise order
         Given the node map
@@ -241,23 +241,23 @@ Feature: Basic Roundabout
            | behkb | roundabout | yes    |
 
         When I route I should get
-           | waypoints | route       | turns                           |
-           | a,c       | abc,abc,abc | depart,roundabout-exit-4,arrive |
-           | a,l       | abc,jkl,jkl | depart,roundabout-exit-3,arrive |
-           | a,i       | abc,ghi,ghi | depart,roundabout-exit-2,arrive |
-           | a,f       | abc,def,def | depart,roundabout-exit-1,arrive |
-           | d,f       | def,def,def | depart,roundabout-exit-4,arrive |
-           | d,c       | def,abc,abc | depart,roundabout-exit-3,arrive |
-           | d,l       | def,jkl,jkl | depart,roundabout-exit-2,arrive |
-           | d,i       | def,ghi,ghi | depart,roundabout-exit-1,arrive |
-           | g,i       | ghi,ghi,ghi | depart,roundabout-exit-4,arrive |
-           | g,f       | ghi,def,def | depart,roundabout-exit-3,arrive |
-           | g,c       | ghi,abc,abc | depart,roundabout-exit-2,arrive |
-           | g,l       | ghi,jkl,jkl | depart,roundabout-exit-1,arrive |
-           | j,l       | jkl,jkl,jkl | depart,roundabout-exit-4,arrive |
-           | j,i       | jkl,ghi,ghi | depart,roundabout-exit-3,arrive |
-           | j,f       | jkl,def,def | depart,roundabout-exit-2,arrive |
-           | j,c       | jkl,abc,abc | depart,roundabout-exit-1,arrive |
+           | waypoints | route           | turns                                                |
+           | a,c       | abc,abc,abc,abc | depart,roundabout-exit-4,exit roundabout left,arrive |
+           | a,l       | abc,jkl,jkl,jkl | depart,roundabout-exit-3,exit roundabout left,arrive |
+           | a,i       | abc,ghi,ghi,ghi | depart,roundabout-exit-2,exit roundabout left,arrive |
+           | a,f       | abc,def,def,def | depart,roundabout-exit-1,exit roundabout left,arrive |
+           | d,f       | def,def,def,def | depart,roundabout-exit-4,exit roundabout left,arrive |
+           | d,c       | def,abc,abc,abc | depart,roundabout-exit-3,exit roundabout left,arrive |
+           | d,l       | def,jkl,jkl,jkl | depart,roundabout-exit-2,exit roundabout left,arrive |
+           | d,i       | def,ghi,ghi,ghi | depart,roundabout-exit-1,exit roundabout left,arrive |
+           | g,i       | ghi,ghi,ghi,ghi | depart,roundabout-exit-4,exit roundabout left,arrive |
+           | g,f       | ghi,def,def,def | depart,roundabout-exit-3,exit roundabout left,arrive |
+           | g,c       | ghi,abc,abc,abc | depart,roundabout-exit-2,exit roundabout left,arrive |
+           | g,l       | ghi,jkl,jkl,jkl | depart,roundabout-exit-1,exit roundabout left,arrive |
+           | j,l       | jkl,jkl,jkl,jkl | depart,roundabout-exit-4,exit roundabout left,arrive |
+           | j,i       | jkl,ghi,ghi,ghi | depart,roundabout-exit-3,exit roundabout left,arrive |
+           | j,f       | jkl,def,def,def | depart,roundabout-exit-2,exit roundabout left,arrive |
+           | j,c       | jkl,abc,abc,abc | depart,roundabout-exit-1,exit roundabout left,arrive |
 
     Scenario: Mixed Entry and Exit - segregated roads, different names
         Given the node map
@@ -284,23 +284,23 @@ Feature: Basic Roundabout
            | bkheb | roundabout | yes    |
 
         When I route I should get
-           | waypoints | route    | turns                           |
-           | a,c       | ab,bc,bc | depart,roundabout-exit-4,arrive |
-           | a,l       | ab,kl,kl | depart,roundabout-exit-1,arrive |
-           | a,i       | ab,hi,hi | depart,roundabout-exit-2,arrive |
-           | a,f       | ab,ef,ef | depart,roundabout-exit-3,arrive |
-           | d,f       | de,ef,ef | depart,roundabout-exit-4,arrive |
-           | d,c       | de,bc,bc | depart,roundabout-exit-1,arrive |
-           | d,l       | de,kl,kl | depart,roundabout-exit-2,arrive |
-           | d,i       | de,hi,hi | depart,roundabout-exit-3,arrive |
-           | g,i       | gh,hi,hi | depart,roundabout-exit-4,arrive |
-           | g,f       | gh,ef,ef | depart,roundabout-exit-1,arrive |
-           | g,c       | gh,bc,bc | depart,roundabout-exit-2,arrive |
-           | g,l       | gh,kl,kl | depart,roundabout-exit-3,arrive |
-           | j,l       | jk,kl,kl | depart,roundabout-exit-4,arrive |
-           | j,i       | jk,hi,hi | depart,roundabout-exit-1,arrive |
-           | j,f       | jk,ef,ef | depart,roundabout-exit-2,arrive |
-           | j,c       | jk,bc,bc | depart,roundabout-exit-3,arrive |
+           | waypoints | route       | turns                                                 |
+           | a,c       | ab,bc,bc,bc | depart,roundabout-exit-4,exit roundabout right,arrive |
+           | a,l       | ab,kl,kl,kl | depart,roundabout-exit-1,exit roundabout right,arrive |
+           | a,i       | ab,hi,hi,hi | depart,roundabout-exit-2,exit roundabout right,arrive |
+           | a,f       | ab,ef,ef,ef | depart,roundabout-exit-3,exit roundabout right,arrive |
+           | d,f       | de,ef,ef,ef | depart,roundabout-exit-4,exit roundabout right,arrive |
+           | d,c       | de,bc,bc,bc | depart,roundabout-exit-1,exit roundabout right,arrive |
+           | d,l       | de,kl,kl,kl | depart,roundabout-exit-2,exit roundabout right,arrive |
+           | d,i       | de,hi,hi,hi | depart,roundabout-exit-3,exit roundabout right,arrive |
+           | g,i       | gh,hi,hi,hi | depart,roundabout-exit-4,exit roundabout right,arrive |
+           | g,f       | gh,ef,ef,ef | depart,roundabout-exit-1,exit roundabout right,arrive |
+           | g,c       | gh,bc,bc,bc | depart,roundabout-exit-2,exit roundabout right,arrive |
+           | g,l       | gh,kl,kl,kl | depart,roundabout-exit-3,exit roundabout right,arrive |
+           | j,l       | jk,kl,kl,kl | depart,roundabout-exit-4,exit roundabout right,arrive |
+           | j,i       | jk,hi,hi,hi | depart,roundabout-exit-1,exit roundabout right,arrive |
+           | j,f       | jk,ef,ef,ef | depart,roundabout-exit-2,exit roundabout right,arrive |
+           | j,c       | jk,bc,bc,bc | depart,roundabout-exit-3,exit roundabout right,arrive |
 
     Scenario: Motorway Roundabout
     #See 39.933742 -75.082345
@@ -338,11 +338,10 @@ Feature: Basic Roundabout
             | dmg   | roundabout |          | trunk_link | yes    |        |
 
         When I route I should get
-            | waypoints | route                                                 | turns                           | ref                     |
-            | a,e       | crescent,crescent,crescent                            | depart,roundabout-exit-3,arrive | US 130,US 130,US 130    |
-            | j,l       | ,,                                                    | depart,roundabout-exit-2,arrive | NJ 38,NJ 38,NJ 38       |
+            | waypoints | route                               | turns                                                    | ref                         |
+            | a,e       | crescent,crescent,crescent,crescent | depart,roundabout-exit-3,exit roundabout straight,arrive | US 130,US 130,US 130,US 130 |
+            | j,l       | ,,,                                 | depart,roundabout-exit-2,exit roundabout straight,arrive | NJ 38,NJ 38,NJ 38,NJ 38     |
 
-    @todo
     # this test previously only passed by accident. We need to handle throughabouts correctly, since staying on massachusetts is actually
     # the desired setting. Rotary instructions here are not wanted but rather no instruction at all to go through the roundabout (or add
     # a throughabout instruction)
@@ -389,8 +388,8 @@ Feature: Basic Roundabout
             | restriction | pi       | ij     | i        | no_left_turn  |
 
         When I route I should get
-            | waypoints | route                                                   | turns                                              |
-            | a,k       | massachusetts,massachusetts,massachusetts,massachusetts | depart,sheridan circle-exit-2,rotary-exit-1,arrive |
+            | waypoints | route                                                   | turns                                                  |
+            | a,k       | massachusetts,massachusetts,massachusetts,massachusetts | depart,sheridan circle-exit-2,exit rotary right,arrive |
 
     #2856 - http://www.openstreetmap.org/#map=19/47.23318/-1.56563
     Scenario: Linked Roundabouts
@@ -477,8 +476,8 @@ Feature: Basic Roundabout
             | cdefib | roundabout | roundabout    | yes    |                       |
 
         When I route I should get
-            | waypoints | route                                  | turns                           |
-            | 1,h       | roundabout,right-bot-out,right-bot-out | depart,roundabout-exit-1,arrive |
+            | waypoints | route                                  | turns                              |
+            | 1,h       | roundabout,right-bot-out,right-bot-out | depart,exit rotary straight,arrive |
 
     @3254
     Scenario: Driving up to and through a roundabout
@@ -495,15 +494,15 @@ Feature: Basic Roundabout
 
         And the ways
             | nodes | junction   | name       | highway     |
-            | abcda | roundabout | roundabout | residential |
+            | abcda | roundabout | rotary     | residential |
             | gfi   |            | side       | residential |
             | efb   |            | left       | residential |
             | dh    |            | right      | residential |
             | ck    |            | bottom     | residential |
 
         When I route I should get
-            | waypoints | route            | turns                           |
-            | e,h       | left,right,right | depart,roundabout-exit-2,arrive |
+            | waypoints | route                  | turns                                         |
+            | e,h       | left,right,right,right | depart,rotary-exit-2,exit rotary right,arrive |
 
     @3254
     Scenario: Driving up to and through a roundabout
@@ -520,15 +519,15 @@ Feature: Basic Roundabout
 
         And the ways
             | nodes | junction   | name       | highway     |
-            | abcda | roundabout | roundabout | residential |
+            | abcda | roundabout | rotary     | residential |
             | gfi   |            | side       | residential |
             | efb   |            | left       | residential |
             | dh    |            | right      | residential |
             | ck    |            | bottom     | residential |
 
         When I route I should get
-            | waypoints | route            | turns                           |
-            | e,h       | left,right,right | depart,roundabout-exit-2,arrive |
+            | waypoints | route                  | turns                                         |
+            | e,h       | left,right,right,right | depart,rotary-exit-2,exit rotary right,arrive |
 
     @3361
     Scenario: Bersarinplatz (Not a Roundabout)
@@ -565,13 +564,13 @@ Feature: Basic Roundabout
             | mn        |            | Petersburger Strasse | B 96a | primary     | yes    |
 
         When I route I should get
-            | waypoints | route                                                          | turns                                                                            |
-            | a,g       | Petersburger Strasse,Petersburger Strasse,Petersburger Strasse | depart,Bersarinplatz-exit-2,arrive |
-            | d,g       | Weidenweg,Petersburger Strasse,Petersburger Strasse            | depart,Bersarinplatz-exit-1,arrive |
-            | i,k       | Petersburger Strasse,Rigaer Strasse,Rigaer Strasse             | depart,Bersarinplatz-exit-1,arrive |
-            | i,n       | Petersburger Strasse,Petersburger Strasse,Petersburger Strasse | depart,Bersarinplatz-exit-2,arrive |
-            | i,d       | Petersburger Strasse,Weidenweg,Weidenweg                       | depart,Bersarinplatz-exit-3,arrive |
-            | i,g       | Petersburger Strasse,Petersburger Strasse,Petersburger Strasse | depart,Bersarinplatz-exit-4,arrive |
+            | waypoints | route                                                                               | turns                                                   |
+            | a,g       | Petersburger Strasse,Petersburger Strasse,Petersburger Strasse,Petersburger Strasse | depart,Bersarinplatz-exit-2,exit rotary straight,arrive |
+            | d,g       | Weidenweg,Petersburger Strasse,Petersburger Strasse,Petersburger Strasse            | depart,Bersarinplatz-exit-1,exit rotary straight,arrive |
+            | i,k       | Petersburger Strasse,Rigaer Strasse,Rigaer Strasse,Rigaer Strasse                   | depart,Bersarinplatz-exit-1,exit rotary right,arrive    |
+            | i,n       | Petersburger Strasse,Petersburger Strasse,Petersburger Strasse,Petersburger Strasse | depart,Bersarinplatz-exit-2,exit rotary straight,arrive |
+            | i,d       | Petersburger Strasse,Weidenweg,Weidenweg,Weidenweg                                  | depart,Bersarinplatz-exit-3,exit rotary right,arrive    |
+            | i,g       | Petersburger Strasse,Petersburger Strasse,Petersburger Strasse,Petersburger Strasse | depart,Bersarinplatz-exit-4,exit rotary straight,arrive |
 
     @turboroundabout
     # http://www.openstreetmap.org/?mlat=48.782118&mlon=8.194456&zoom=16#map=19/48.78216/8.19457
@@ -606,11 +605,11 @@ Feature: Basic Roundabout
             | ob    | trunk       | yes    | roundabout | Europaplatz   |                                        |
 
        When I route I should get
-           | waypoints | route                        | turns                            |
-           | a,d       | ,Europastrasse,Europastrasse | depart,Europaplatz-exit-1,arrive |
-           | a,h       | ,Allee Cite,Allee Cite       | depart,Europaplatz-exit-2,arrive |
-           | a,l       | ,Europastrasse,Europastrasse | depart,Europaplatz-exit-3,arrive |
-           | a,p       | ,,                           | depart,Europaplatz-exit-4,arrive |
+           | waypoints | route                                      | turns                                              |
+           | a,d       | ,Europastrasse,Europastrasse,Europastrasse | depart,Europaplatz-exit-1,exit rotary right,arrive |
+           | a,h       | ,Allee Cite,Allee Cite,Allee Cite          | depart,Europaplatz-exit-2,exit rotary right,arrive |
+           | a,l       | ,Europastrasse,Europastrasse,Europastrasse | depart,Europaplatz-exit-3,exit rotary right,arrive |
+           | a,p       | ,,,                                        | depart,Europaplatz-exit-4,exit rotary right,arrive |
 
     @turboroundabout
     # http://www.openstreetmap.org/?mlat=50.180039&mlon=8.474939&zoom=16#map=19/50.17999/8.47506
@@ -658,14 +657,14 @@ Feature: Basic Roundabout
             | wb    | primary      | yes    | roundabout |                              | through\|through;right             |
 
        When I route I should get
-           | waypoints | route                                                                      | turns                                   |
-           | a,w       | Le-Cannet-Rocheville-Strasse,,                                             | depart,roundabout-exit-undefined,arrive |
-           | a,r       | Le-Cannet-Rocheville-Strasse,,                                             | depart,roundabout-exit-4,arrive         |
-           | a,f       | Le-Cannet-Rocheville-Strasse,Frankfurter Strasse,Frankfurter Strasse       | depart,roundabout-exit-1,arrive         |
-           | a,h       | Le-Cannet-Rocheville-Strasse,Bischof-Kaller-Strasse,Bischof-Kaller-Strasse | depart,roundabout-exit-2,arrive         |
-           | u,r       | ,,                                                                         | depart,roundabout-exit-5,arrive         |
-           | j,h       | Bischof-Kaller-Strasse,Bischof-Kaller-Strasse,Bischof-Kaller-Strasse       | depart,roundabout-exit-5,arrive         |
-           | n,m       | ,                                                                          | depart,arrive                           |
+           | waypoints | route                                                                                             | turns                                                 |
+           | a,w       | Le-Cannet-Rocheville-Strasse,,                                                                    | depart,roundabout-exit-undefined,arrive               |
+           | a,r       | Le-Cannet-Rocheville-Strasse,,,                                                                   | depart,roundabout-exit-4,exit roundabout right,arrive |
+           | a,f       | Le-Cannet-Rocheville-Strasse,Frankfurter Strasse,Frankfurter Strasse,Frankfurter Strasse          | depart,roundabout-exit-1,exit roundabout right,arrive |
+           | a,h       | Le-Cannet-Rocheville-Strasse,Bischof-Kaller-Strasse,Bischof-Kaller-Strasse,Bischof-Kaller-Strasse | depart,roundabout-exit-2,exit roundabout right,arrive |
+           | u,r       | ,,,                                                                                               | depart,roundabout-exit-5,exit roundabout right,arrive |
+           | j,h       | Bischof-Kaller-Strasse,Bischof-Kaller-Strasse,Bischof-Kaller-Strasse,Bischof-Kaller-Strasse       | depart,roundabout-exit-5,exit roundabout right,arrive |
+           | n,m       | ,                                                                                                 | depart,arrive                                         |
 
     @turboroundabout
     # http://www.openstreetmap.org/?mlat=47.57723&mlon=7.796765&zoom=16#map=19/47.57720/7.79711
@@ -708,17 +707,16 @@ Feature: Basic Roundabout
             | la    | primary      | yes    | roundabout |
 
        When I route I should get
-           | waypoints | route    | turns                           |
-           | w,r       | wk,ar,ar | depart,roundabout-exit-1,arrive |
-           | w,s       | wk,ds,ds | depart,roundabout-exit-2,arrive |
-           | w,t       | wk,ft,ft | depart,roundabout-exit-3,arrive |
-           | w,v       | wk,hv,hv | depart,roundabout-exit-4,arrive |
-           | u,v       | ug,hv,hv | depart,roundabout-exit-1,arrive |
-           | u,w       | ug,jw,jw | depart,roundabout-exit-2,arrive |
-           | u,r       | ug,ar,ar | depart,roundabout-exit-3,arrive |
-           | u,s       | ug,ds,ds | depart,roundabout-exit-4,arrive |
-           | u,t       | ug,ft,ft | depart,roundabout-exit-5,arrive |
-
+           | waypoints | route       | turns                                                        |
+           | w,r       | wk,ar,ar,ar | depart,roundabout-exit-1,exit roundabout slight right,arrive |
+           | w,s       | wk,ds,ds,ds | depart,roundabout-exit-2,exit roundabout right,arrive        |
+           | w,t       | wk,ft,ft,ft | depart,roundabout-exit-3,exit roundabout right,arrive        |
+           | w,v       | wk,hv,hv,hv | depart,roundabout-exit-4,exit roundabout straight,arrive     |
+           | u,v       | ug,hv,hv,hv | depart,roundabout-exit-1,exit roundabout straight,arrive     |
+           | u,w       | ug,jw,jw,jw | depart,roundabout-exit-2,exit roundabout slight right,arrive |
+           | u,r       | ug,ar,ar,ar | depart,roundabout-exit-3,exit roundabout slight right,arrive |
+           | u,s       | ug,ds,ds,ds | depart,roundabout-exit-4,exit roundabout right,arrive        |
+           | u,t       | ug,ft,ft,ft | depart,roundabout-exit-5,exit roundabout right,arrive        |
 
     @3762
     Scenario: Only Enter
@@ -742,8 +740,8 @@ Feature: Basic Roundabout
             | bcjdeb | roundabout |       |
 
         When I route I should get
-            | waypoints | route          | turns                                                                           |
-            | a,h       | ab,ef,ef,fh,fh | depart,roundabout-exit-4,notification slight right,notification straight,arrive |
+            | waypoints | route          | turns                                                                              |
+            | a,h       | ab,ef,ef,fh,fh | depart,roundabout-exit-4,exit roundabout slight right,notification straight,arrive |
 
 
      Scenario: Drive through roundabout
@@ -762,12 +760,12 @@ Feature: Basic Roundabout
            | gch   |            | yes    |
 
         When I route I should get
-           | waypoints | bearings | route       | turns                           |
-           | e,f       | 90 90    | edf,edf     | depart,arrive                   |
-           | e,h       | 90 135   | edf,gch,gch | depart,roundabout-exit-2,arrive |
-           | g,f       | 45 90    | gch,edf,edf | depart,roundabout-exit-2,arrive |
-           | g,h       | 45 135   | gch,gch,gch | depart,roundabout-exit-1,arrive |
-           | e,e       | 90 270   | edf,edf,edf | depart,roundabout-exit-3,arrive |
+           | waypoints | bearings | route           | turns                                                      |
+           | e,f       | 90 90    | edf,edf         | depart,arrive                                              |
+           | e,h       | 90 135   | edf,gch,gch,gch | depart,roundabout-exit-2,exit roundabout straight,arrive   |
+           | g,f       | 45 90    | gch,edf,edf,edf | depart,roundabout-exit-2,exit roundabout right,arrive      |
+           | g,h       | 45 135   | gch,gch,gch     | depart,exit roundabout right,arrive                        |
+           | e,e       | 90 270   | edf,edf,edf,edf | depart,roundabout-exit-3,exit roundabout sharp left,arrive |
 
     Scenario: CCW and CW roundabouts with overlaps
         Given the node map
@@ -787,12 +785,13 @@ Feature: Basic Roundabout
             | kg    | tertiary |            |
             | hl    | tertiary |            |
 
+        # the turn angles here are quite strange, so we do get uturns for exiting
         When I route I should get
-            | from | to | route    | turns                           | distance |
-            | e    | f  | ed,af,af | depart,roundabout-exit-1,arrive | 80.1m    |
-            | f    | e  | af,ed,ed | depart,roundabout-exit-1,arrive | 120.1m   |
-            | k    | l  | kg,hl,hl | depart,roundabout-exit-1,arrive | 80.1m    |
-            | l    | k  | hl,kg,kg | depart,roundabout-exit-1,arrive | 120.1m   |
+            | from | to | route       | turns                                                 | distance |
+            | e    | f  | ed,af,af,af | depart,roundabout-exit-1,exit roundabout left,arrive  | 80.1m    |
+            | f    | e  | af,ed,ed,ed | depart,roundabout-exit-1,exit roundabout uturn,arrive | 120.1m   |
+            | k    | l  | kg,hl,hl,hl | depart,roundabout-exit-1,exit roundabout right,arrive | 80.1m    |
+            | l    | k  | hl,kg,kg,kg | depart,roundabout-exit-1,exit roundabout uturn,arrive | 120.1m   |
 
     @4030 @4075
     Scenario: Service roundabout with service exits
@@ -811,11 +810,11 @@ Feature: Basic Roundabout
             | bh    | service  |            |
 
         When I route I should get
-            | from | to | route       | turns                           |
-            |    1 | e  | abcda,ce,ce | depart,roundabout-exit-1,arrive |
-            |    1 | f  | abcda,df,df | depart,roundabout-exit-2,arrive |
-            |    1 | g  | abcda,ag,ag | depart,roundabout-exit-3,arrive |
-            |    1 | h  | abcda,bh,bh | depart,roundabout-exit-4,arrive |
+            | from | to | route       | turns                                   |
+            |    1 | e  | abcda,ce,ce | depart,exit roundabout straight,arrive  |
+            |    1 | f  | abcda,df,df | depart,exit roundabout right,arrive     |
+            |    1 | g  | abcda,ag,ag | depart,exit roundabout straight,arrive  |
+            |    1 | h  | abcda,bh,bh | depart,exit roundabout right,arrive     |
 
     Scenario: Collapsing a sliproad step after roundabouts
         Given the node map
@@ -843,6 +842,6 @@ Feature: Basic Roundabout
 
 
         When I route I should get
-            | from | to | route                | turns                                 | distance |
-            | e    | k  | ebds,ufghl,jhik,jhik | depart,rstur-exit-2,turn right,arrive | 189.1m   |
-            | 1    | k  | ebds,ufghl,jhik,jhik | depart,rstur-exit-2,turn right,arrive | 159.1m   |
+            | from | to | route                      | turns                                                   | distance |
+            | e    | k  | ebds,ufghl,ufghl,jhik,jhik | depart,rstur-exit-2,exit rotary right,turn right,arrive | 189.1m   |
+            | 1    | k  | ebds,ufghl,ufghl,jhik,jhik | depart,rstur-exit-2,exit rotary right,turn right,arrive | 159.1m   |

features/guidance/turn-angles.feature

@@ -248,8 +248,8 @@ Feature: Simple Turns
             | bcdefghijklmnob | residential | road | 1     | yes    | roundabout |
 
        When I route I should get
-            | waypoints | route               | turns                                         | intersections                                                            |
-            | a,p       | road,road,road      | depart,roundabout turn straight exit-1,arrive | true:90;true:165 false:270 false:345,true:90 false:180 true:345;true:270 |
+            | waypoints | route          | turns                                         | intersections                                                            |
+            | a,p       | road,road,road | depart,roundabout turn straight exit-1,arrive | true:90;true:165 false:270 false:345,true:90 false:180 true:345;true:270 |
 
     Scenario: Splitting Road with many lanes
         Given the node map
@@ -809,14 +809,14 @@ Feature: Simple Turns
 
         When I route I should get
             | waypoints | route               | turns                    | intersections                                         |
-            | a,g       | Perle,Heide,Heide   | depart,turn right,arrive | true:90;true:90 true:180 false:270 true:345;true:18   |
-            | a,k       | Perle,Friede,Friede | depart,turn left,arrive  | true:90;true:90 true:180 false:270 true:345;true:153  |
-            | a,e       | Perle,Perle         | depart,arrive            | true:90,true:90 true:180 false:270 true:345;true:270  |
-            | e,k       | Perle,Friede,Friede | depart,turn right,arrive | true:270;false:90 true:180 true:270 true:345;true:153 |
-            | e,g       | Perle,Heide,Heide   | depart,turn left,arrive  | true:270;false:90 true:180 true:270 true:345;true:18  |
-            | h,k       | Heide,Friede        | depart,arrive            | true:16,true:90 true:180 true:270 true:345;true:153   |
-            | h,e       | Heide,Perle,Perle   | depart,turn right,arrive | true:16;true:90 true:180 true:270 true:345;true:270   |
-            | h,a       | Heide,Perle,Perle   | depart,turn left,arrive  | true:16;true:90 true:180 true:270 true:345;true:90    |
+            | a,g       | Perle,Heide,Heide   | depart,turn right,arrive | true:90;true:90 true:195 false:270 true:345;true:18   |
+            | a,k       | Perle,Friede,Friede | depart,turn left,arrive  | true:90;true:90 true:195 false:270 true:345;true:153  |
+            | a,e       | Perle,Perle         | depart,arrive            | true:90,true:90 true:195 false:270 true:345;true:270  |
+            | e,k       | Perle,Friede,Friede | depart,turn right,arrive | true:270;false:90 true:195 true:270 true:345;true:153 |
+            | e,g       | Perle,Heide,Heide   | depart,turn left,arrive  | true:270;false:90 true:195 true:270 true:345;true:18  |
+            | h,k       | Heide,Friede        | depart,arrive            | true:16,true:90 true:195 true:270 true:345;true:153   |
+            | h,e       | Heide,Perle,Perle   | depart,turn right,arrive | true:16;true:90 true:195 true:270 true:345;true:270   |
+            | h,a       | Heide,Perle,Perle   | depart,turn left,arrive  | true:16;true:90 true:195 true:270 true:345;true:90    |
 
     #http://www.openstreetmap.org/#map=19/52.53293/13.32956
     Scenario: Curved Exit from Curved Road
@@ -1006,8 +1006,8 @@ Feature: Simple Turns
             | waypoints | route               | turns                          |
             | a,e       | Heide,Heide,Heide   | depart,continue uturn,arrive   |
             | a,g       | Heide,Fenn,Fenn     | depart,turn right,arrive       |
-            | a,h       | Heide,Friede,Friede | depart,turn slight left,arrive |
-            | i,e       | Perle,Heide,Heide   | depart,turn right,arrive       |
+            | a,h       | Heide,Friede,Friede | depart,turn left,arrive        |
+            | i,e       | Perle,Heide,Heide   | depart,turn sharp right,arrive |
             | i,h       | Perle,Friede,Friede | depart,turn left,arrive        |
 
     #http://www.openstreetmap.org/#map=19/52.48630/13.36017
@@ -1189,7 +1189,7 @@ Feature: Simple Turns
 
         When I route I should get
             | waypoints | route             | turns                           |
-            | a,c       | rose,trift        | depart,arrive                   |
+            | a,c       | rose,trift,trift  | depart,turn slight left,arrive  |
             | a,k       | rose,muhle,muhle  | depart,turn slight right,arrive |
             | d,f       | trift,rose        | depart,arrive                   |
             | d,k       | trift,muhle,muhle | depart,turn sharp left,arrive   |
@@ -1317,11 +1317,11 @@ Feature: Simple Turns
 
     #https://github.com/Project-OSRM/osrm-backend/pull/3469#issuecomment-270806580
     Scenario: Oszillating Lower Priority Road
-		#Given the node map
-	#		"""
-	#		a -db    c
+        #Given the node map
+    #       """
+    #       a -db    c
     #           f
-    #   	"""
+    #       """
         Given the node locations
             | node | lat                | lon                | #          |
             | a    | 1.0                | 1.0                |            |

features/guidance/turn-lanes.feature

@@ -835,9 +835,9 @@ Feature: Turn Lane Guidance
             | cf    | secondary | bottom |                    |
 
         When I route I should get
-            | waypoints | turns                                   | route               | lanes                        |
-            | a,d       | depart,continue right,turn right,arrive | road,road,road,road | ,straight:false right:true,, |
-            | d,a       | depart,continue left,turn left,arrive   | road,road,road,road | ,left:true straight:false,,  |
+            | waypoints | turns                                       | route               | lanes                        |
+            | a,d       | depart,continue right,continue right,arrive | road,road,road,road | ,straight:false right:true,, |
+            | d,a       | depart,continue left,continue left,arrive   | road,road,road,road | ,left:true straight:false,,  |
 
     @simple
     Scenario: Merge Lanes Onto Freeway

features/guidance/turn.feature

@@ -788,9 +788,9 @@ Feature: Simple Turns
             | bg    | primary | yes    |
 
         When I route I should get
-            | waypoints | route     | turns                          |
-            | a,d       | abc,bd,bd | depart,turn sharp right,arrive |
-            | a,f       | abc,bf,bf | depart,turn right,arrive       |
+            | waypoints | route     | turns                           |
+            | a,d       | abc,bd,bd | depart,turn right,arrive        |
+            | a,f       | abc,bf,bf | depart,turn slight right,arrive |
 
     Scenario: Right Turn Assignment Three Conflicting Turns with invalid - 3
         Given the node map

features/testbot/approaches.feature

@@ -167,7 +167,7 @@ Feature: Approach parameter
             | s    | e  | unrestricted curb |       |
 
 
-    Scenario: UTurn test, router can found a route because he can use the roundabout
+    Scenario: UTurn test, router can find a route because he can use the roundabout
         Given the node map
             """
                              h

features/testbot/datastore.feature

@@ -1,35 +0,0 @@
-@routing @datastore @testbot
-Feature: Temporary tests related to osrm-datastore
-
-    Background:
-        Given the profile "testbot"
-
-    Scenario: Scenario ab
-        Given the node map
-            """
-            a b
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-
-        When I route I should get
-            | from | to | route |
-            | a    | b  | ab,ab |
-            | b    | a  | ab,ab |
-
-    Scenario: Scenaria xy
-        Given the node map
-            """
-            x y
-            """
-
-        And the ways
-            | nodes |
-            | xy    |
-
-        When I route I should get
-            | from | to | route |
-            | x    | y  | xy,xy |
-            | y    | x  | xy,xy |

features/testbot/distance.feature

@@ -226,23 +226,3 @@ Feature: Distance calculation
             | x    | v  | xv,xv | 424m +-1 |
             | x    | w  | xw,xw | 360m +-1 |
             | x    | y  | xy,xy | 316m +-1 |
-
-    @maze
-    Scenario: Distance of a maze of short segments
-        Given a grid size of 7 meters
-        Given the node map
-            """
-            a b s t
-            d c r q
-            e f o p
-            h g n m
-            i j k l
-            """
-
-        And the ways
-            | nodes                |
-            | abcdefghijklmnopqrst |
-
-        When I route I should get
-            | from | to | route                                     | distance |
-            | a    | t  | abcdefghijklmnopqrst,abcdefghijklmnopqrst | 133m +-1 |

features/testbot/duration.feature

@@ -21,12 +21,12 @@ Feature: Durations
             | ef    | primary | 01:02:03 |
 
         When I route I should get
-            | from | to | route | distance | time       |
-            | a    | b  | ab,ab | 100m +-1 | 60s +-1    |
-            | b    | c  | bc,bc | 200m +-1 | 600s +-1   |
-            | c    | d  | cd,cd | 300m +-1 | 3600s +-1  |
-            | d    | e  | de,de | 141m +-2 | 36000s +-1 |
-            | e    | f  | ef,ef | 224m +-2 | 3723s +-1  |
+            | from | to | route | time       |
+            | a    | b  | ab,ab | 60s +-1    |
+            | b    | c  | bc,bc | 600s +-1   |
+            | c    | d  | cd,cd | 3600s +-1  |
+            | d    | e  | de,de | 36000s +-1 |
+            | e    | f  | ef,ef | 3723s +-1  |
 
     @todo
     Scenario: Partial duration of ways
@@ -40,7 +40,7 @@ Feature: Durations
             | abc   | primary | 0:01     |
 
         When I route I should get
-            | from | to | route   | distance | time    |
-            | a    | c  | abc,abc | 300m +-1 | 60s +-1 |
-            | a    | b  | ab,ab   | 100m +-1 | 20s +-1 |
-            | b    | c  | bc,bc   | 200m +-1 | 40s +-1 |
+            | from | to | route   | time    |
+            | a    | c  | abc,abc | 60s +-1 |
+            | a    | b  | ab,ab   | 20s +-1 |
+            | b    | c  | bc,bc   | 40s +-1 |

features/testbot/oneway.feature

@@ -5,51 +5,6 @@ Feature: Testbot - oneways
         Given the profile "testbot"
         Given a grid size of 250 meters
 
-    Scenario: Routing on a oneway roundabout
-        Given the node map
-        """
-                v
-        x   d c
-          e     b
-          f     a
-            g h   y
-          z
-        """
-
-        And the ways
-            | nodes | oneway |
-            | ab    | yes    |
-            | bc    | yes    |
-            | cd    | yes    |
-            | de    | yes    |
-            | ef    | yes    |
-            | fg    | yes    |
-            | gh    | yes    |
-            | ha    | yes    |
-            | vx    | yes    |
-            | vy    | yes    |
-            | yz    | yes    |
-            | xe    | yes    |
-
-        When I route I should get
-            | from | to | route                   |
-            | a    | b  | ab,ab                   |
-            | b    | c  | bc,bc                   |
-            | c    | d  | cd,cd                   |
-            | d    | e  | de,de                   |
-            | e    | f  | ef,ef                   |
-            | f    | g  | fg,fg                   |
-            | g    | h  | gh,gh                   |
-            | h    | a  | ha,ha                   |
-            | b    | a  | bc,cd,de,ef,fg,gh,ha,ha |
-            | c    | b  | cd,de,ef,fg,gh,ha,ab,ab |
-            | d    | c  | de,ef,fg,gh,ha,ab,bc,bc |
-            | e    | d  | ef,fg,gh,ha,ab,bc,cd,cd |
-            | f    | e  | fg,gh,ha,ab,bc,cd,de,de |
-            | g    | f  | gh,ha,ab,bc,cd,de,ef,ef |
-            | h    | g  | ha,ab,bc,cd,de,ef,fg,fg |
-            | a    | h  | ab,bc,cd,de,ef,fg,gh,gh |
-
     Scenario: Testbot - Simple oneway
         Then routability should be
             | highway | foot | oneway | forw | backw |
@@ -60,27 +15,6 @@ Feature: Testbot - oneways
             | highway | foot | oneway | forw | backw |
             | primary | no   | -1     |      | x     |
 
-    Scenario: Testbot - Around the Block
-        Given the node map
-            """
-              a b
-            e d c f
-            """
-
-        And the ways
-            | nodes | oneway | foot |
-            | ab    | yes    | no   |
-            | bc    |        | no   |
-            | cd    |        | no   |
-            | da    |        | no   |
-            | de    |        | no   |
-            | cf    |        | no   |
-
-        When I route I should get
-            | from | to | route       |
-            | a    | b  | ab,ab       |
-            | b    | a  | bc,cd,da,da |
-
     Scenario: Testbot - Handle various oneway tag values
         Then routability should be
             | foot | oneway   | forw | backw |
@@ -93,19 +27,3 @@ Feature: Testbot - oneways
             | no   | true     | x    |       |
             | no   | 1        | x    |       |
             | no   | -1       |      | x     |
-
-    Scenario: Testbot - Two consecutive oneways
-        Given the node map
-            """
-            a b c
-            """
-
-        And the ways
-            | nodes | oneway |
-            | ab    | yes    |
-            | bc    | yes    |
-
-
-        When I route I should get
-            | from | to | route    |
-            | a    | c  | ab,bc,bc |

features/testbot/penalty.feature

@@ -26,6 +26,33 @@ Feature: Penalties
             | a    | c  | abc,abc | 20s +-1 | 200m +-1 |
             | d    | f  | def,def | 27s +-1 | 200m +-1 |
 
+    # Penalties not on the phantom nodes
+    Scenario: Traffic signals should incur a delay, without changing distance
+        Given the node map
+            """
+            a b c d e
+            f g h i j
+            """
+
+        And the nodes
+            | node | highway         |
+            | c    | traffic_signals |
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bcd   |
+            | de    |
+            | fg    |
+            | ghi   |
+            | ij    |
+
+        When I route I should get
+            | from | to | route     | time    | distance |
+            | a    | e  | ab,bcd,de | 47s +-1 | 400m +-1 |
+            | f    | j  | fg,ghi,ij | 40s +-1 | 400m +-1 |
+
+
     Scenario: Signal penalty should not depend on way type
         Given the node map
             """
@@ -72,55 +99,35 @@ Feature: Penalties
             | from | to | route       | time    |
             | a    | e  | abcde,abcde | 61s +-1 |
 
-        @todo
-        Scenario: Signal penalty should not depend on way type
-            Given the node map
-                """
-                a b c
-                d e f
-                g h i
-                """
+    @todo
+    Scenario: Signal penalty should not depend on way type
+        Given the node map
+            """
+            a b c
+            d e f
+            g h i
+            """
 
-            And the nodes
-                | node | highway         |
-                | b    | traffic_signals |
-                | e    | traffic_signals |
-                | h    | traffic_signals |
+        And the nodes
+            | node | highway         |
+            | b    | traffic_signals |
+            | e    | traffic_signals |
+            | h    | traffic_signals |
 
-            And the ways
-                | nodes | highway   |
-                | abc   | primary   |
-                | def   | secondary |
-                | ghi   | tertiary  |
+        And the ways
+            | nodes | highway   |
+            | abc   | primary   |
+            | def   | secondary |
+            | ghi   | tertiary  |
 
-            When I route I should get
-                | from | to | route   | time    |
-                | a    | b  | abc,abc | 10s +-1 |
-                | a    | c  | abc,abc | 27s +-1 |
-                | d    | e  | def,def | 20s +-1 |
-                | d    | f  | def,def | 47s +-1 |
-                | g    | h  | ghi,ghi | 30s +-1 |
-                | g    | i  | ghi,ghi | 67s +-1 |
-
-        Scenario: Passing multiple traffic signals should incur a accumulated delay
-            Given the node map
-                """
-                a b c d e
-                """
-
-            And the nodes
-                | node | highway         |
-                | b    | traffic_signals |
-                | c    | traffic_signals |
-                | d    | traffic_signals |
-
-            And the ways
-                | nodes |
-                | abcde |
-
-            When I route I should get
-                | from | to | route       | time    |
-                | a    | e  | abcde,abcde | 61s +-1 |
+        When I route I should get
+            | from | to | route   | time    |
+            | a    | b  | abc,abc | 10s +-1 |
+            | a    | c  | abc,abc | 27s +-1 |
+            | d    | e  | def,def | 20s +-1 |
+            | d    | f  | def,def | 47s +-1 |
+            | g    | h  | ghi,ghi | 30s +-1 |
+            | g    | i  | ghi,ghi | 67s +-1 |
 
     @todo
     Scenario: Starting or ending at a traffic signal should not incur a delay

include/engine/api/route_api.hpp

@@ -167,12 +167,12 @@ class RouteAPI : public BaseAPI
                  * the overall response consistent.
                  *
                  * ⚠ CAUTION: order of post-processing steps is important
-                 *    - postProcess must be called before collapseTurnInstructions that expects
-                 *      post-processed roundabouts without Exit instructions
+                 *    - handleRoundabouts must be called before collapseTurnInstructions that
+                 *      expects post-processed roundabouts
                  */
 
                 guidance::trimShortSegments(steps, leg_geometry);
-                leg.steps = guidance::postProcess(std::move(steps));
+                leg.steps = guidance::handleRoundabouts(std::move(steps));
                 leg.steps = guidance::collapseTurnInstructions(std::move(leg.steps));
                 leg.steps = guidance::anticipateLaneChange(std::move(leg.steps));
                 leg.steps = guidance::buildIntersections(std::move(leg.steps));

include/engine/datafacade.hpp

@@ -1,13 +1,6 @@
 #ifndef OSRM_ENGINE_DATAFACADE_DATAFACADE_HPP
 #define OSRM_ENGINE_DATAFACADE_DATAFACADE_HPP
 
-#ifdef OSRM_EXTERNAL_MEMORY
-
-// Register your own data backend here
-#error "No external memory implementation found"
-
-#else
-
 #include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
 
 namespace osrm
@@ -22,5 +15,3 @@ using DataFacade = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
 }
 
 #endif
-
-#endif

include/engine/guidance/assemble_geometry.hpp

@@ -11,6 +11,7 @@
 #include "util/coordinate.hpp"
 #include "util/coordinate_calculation.hpp"
 
+#include <algorithm>
 #include <utility>
 #include <vector>
 
@@ -20,7 +21,6 @@ namespace engine
 {
 namespace guidance
 {
-
 // Extracts the geometry for each segment and calculates the traveled distance
 // Combines the geometry form the phantom node with the PathData
 // to the full route geometry.
@@ -53,9 +53,9 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
         source_node.fwd_segment_position + (reversed_source ? 1 : 0);
     const auto source_node_id =
         reversed_source ? source_node.reverse_segment_id.id : source_node.forward_segment_id.id;
-    const auto source_gemetry_id = facade.GetGeometryIndex(source_node_id).id;
-    const std::vector<NodeID> source_geometry =
-        facade.GetUncompressedForwardGeometry(source_gemetry_id);
+    const auto source_geometry_id = facade.GetGeometryIndex(source_node_id).id;
+    std::vector<NodeID> source_geometry = facade.GetUncompressedForwardGeometry(source_geometry_id);
+
     geometry.osm_node_ids.push_back(
         facade.GetOSMNodeIDOfNode(source_geometry[source_segment_start_coordinate]));
 
@@ -78,21 +78,26 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
         }
 
         prev_coordinate = coordinate;
-        geometry.annotations.emplace_back(LegGeometry::Annotation{
-            current_distance,
-            // NOTE: we want annotations to include only the duration/weight
-            //       of the segment itself.  For segments immediately before
-            //       a turn, the duration_until_turn/weight_until_turn values
-            //       include the turn cost.  To counter this, we subtract
-            //       the duration_of_turn/weight_of_turn value, which is 0 for
-            //       non-preceeding-turn segments, but contains the turn value
-            //       for segments before a turn.
-            (path_point.duration_until_turn - path_point.duration_of_turn) / 10.,
-            (path_point.weight_until_turn - path_point.weight_of_turn) /
-                facade.GetWeightMultiplier(),
-            path_point.datasource_id});
-        geometry.locations.push_back(std::move(coordinate));
-        geometry.osm_node_ids.push_back(facade.GetOSMNodeIDOfNode(path_point.turn_via_node));
+
+        const auto osm_node_id = facade.GetOSMNodeIDOfNode(path_point.turn_via_node);
+        if (osm_node_id != geometry.osm_node_ids.back())
+        {
+            geometry.annotations.emplace_back(LegGeometry::Annotation{
+                current_distance,
+                // NOTE: we want annotations to include only the duration/weight
+                //       of the segment itself.  For segments immediately before
+                //       a turn, the duration_until_turn/weight_until_turn values
+                //       include the turn cost.  To counter this, we subtract
+                //       the duration_of_turn/weight_of_turn value, which is 0 for
+                //       non-preceeding-turn segments, but contains the turn value
+                //       for segments before a turn.
+                (path_point.duration_until_turn - path_point.duration_of_turn) / 10.,
+                (path_point.weight_until_turn - path_point.weight_of_turn) /
+                    facade.GetWeightMultiplier(),
+                path_point.datasource_id});
+            geometry.locations.push_back(std::move(coordinate));
+            geometry.osm_node_ids.push_back(osm_node_id);
+        }
     }
     current_distance =
         util::coordinate_calculation::haversineDistance(prev_coordinate, target_node.location);
@@ -102,9 +107,9 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
 
     const auto target_node_id =
         reversed_target ? target_node.reverse_segment_id.id : target_node.forward_segment_id.id;
-    const auto target_gemetry_id = facade.GetGeometryIndex(target_node_id).id;
+    const auto target_geometry_id = facade.GetGeometryIndex(target_node_id).id;
     const std::vector<DatasourceID> forward_datasources =
-        facade.GetUncompressedForwardDatasources(target_gemetry_id);
+        facade.GetUncompressedForwardDatasources(target_geometry_id);
 
     // FIXME if source and target phantoms are on the same segment then duration and weight
     // will be from one projected point till end of segment
@@ -127,7 +132,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
     const auto target_segment_end_coordinate =
         target_node.fwd_segment_position + (reversed_target ? 0 : 1);
     const std::vector<NodeID> target_geometry =
-        facade.GetUncompressedForwardGeometry(target_gemetry_id);
+        facade.GetUncompressedForwardGeometry(target_geometry_id);
     geometry.osm_node_ids.push_back(
         facade.GetOSMNodeIDOfNode(target_geometry[target_segment_end_coordinate]));
 

include/engine/guidance/post_processing.hpp

@@ -17,7 +17,7 @@ namespace guidance
 
 // passed as none-reference to modify in-place and move out again
 OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> postProcess(std::vector<RouteStep> steps);
+std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
 
 // trim initial/final segment of very short length.
 // This function uses in/out parameter passing to modify both steps and geometry in place.

include/engine/internal_route_result.hpp

@@ -1,10 +1,14 @@
 #ifndef RAW_ROUTE_DATA_H
 #define RAW_ROUTE_DATA_H
 
+#include "extractor/class_data.hpp"
 #include "extractor/guidance/turn_instruction.hpp"
 #include "extractor/travel_mode.hpp"
+
 #include "engine/phantom_node.hpp"
+
 #include "osrm/coordinate.hpp"
+
 #include "util/guidance/entry_class.hpp"
 #include "util/guidance/turn_bearing.hpp"
 #include "util/guidance/turn_lanes.hpp"

include/engine/plugins/match.hpp

@@ -5,9 +5,6 @@
 #include "engine/plugins/plugin_base.hpp"
 #include "engine/routing_algorithms.hpp"
 
-#include "engine/map_matching/bayes_classifier.hpp"
-#include "engine/routing_algorithms/map_matching.hpp"
-#include "engine/routing_algorithms/shortest_path.hpp"
 #include "util/json_util.hpp"
 
 #include <vector>

include/engine/plugins/table.hpp

@@ -5,8 +5,7 @@
 
 #include "engine/api/table_parameters.hpp"
 #include "engine/routing_algorithms.hpp"
-#include "engine/routing_algorithms/many_to_many.hpp"
-#include "engine/search_engine_data.hpp"
+
 #include "util/json_container.hpp"
 
 namespace osrm

include/engine/plugins/viaroute.hpp

@@ -3,10 +3,9 @@
 
 #include "engine/plugins/plugin_base.hpp"
 
-#include "engine/api/route_api.hpp"
-#include "engine/datafacade/datafacade_base.hpp"
+#include "engine/api/route_parameters.hpp"
 #include "engine/routing_algorithms.hpp"
-#include "engine/search_engine_data.hpp"
+
 #include "util/json_container.hpp"
 
 #include <cstdlib>

include/engine/routing_algorithms/routing_base.hpp

@@ -134,23 +134,13 @@ void annotatePath(const FacadeT &facade,
     BOOST_ASSERT(phantom_node_pair.target_phantom.forward_segment_id.id == target_node_id ||
                  phantom_node_pair.target_phantom.reverse_segment_id.id == target_node_id);
 
-    auto node_from = unpacked_nodes.begin(), node_last = std::prev(unpacked_nodes.end());
-    for (auto edge = unpacked_edges.begin(); node_from != node_last; ++node_from, ++edge)
-    {
-        const auto &edge_data = facade.GetEdgeData(*edge);
-        const auto turn_id = edge_data.turn_id; // edge-based graph edge index
-        const auto node_id = *node_from;        // edge-based graph node index
-        const auto name_index = facade.GetNameIndex(node_id);
-        const auto turn_instruction = facade.GetTurnInstructionForEdgeID(turn_id);
-        const extractor::TravelMode travel_mode = facade.GetTravelMode(node_id);
-        const auto classes = facade.GetClassData(node_id);
+    // datastructures to hold extracted data from geometry
+    std::vector<NodeID> id_vector;
+    std::vector<EdgeWeight> weight_vector;
+    std::vector<EdgeWeight> duration_vector;
+    std::vector<DatasourceID> datasource_vector;
 
-        const auto geometry_index = facade.GetGeometryIndex(node_id);
-        std::vector<NodeID> id_vector;
-
-        std::vector<EdgeWeight> weight_vector;
-        std::vector<EdgeWeight> duration_vector;
-        std::vector<DatasourceID> datasource_vector;
+    const auto get_segment_geometry = [&](const auto geometry_index) {
         if (geometry_index.forward)
         {
             id_vector = facade.GetUncompressedForwardGeometry(geometry_index.id);
@@ -165,6 +155,22 @@ void annotatePath(const FacadeT &facade,
             duration_vector = facade.GetUncompressedReverseDurations(geometry_index.id);
             datasource_vector = facade.GetUncompressedReverseDatasources(geometry_index.id);
         }
+    };
+
+    auto node_from = unpacked_nodes.begin(), node_last = std::prev(unpacked_nodes.end());
+    for (auto edge = unpacked_edges.begin(); node_from != node_last; ++node_from, ++edge)
+    {
+        const auto &edge_data = facade.GetEdgeData(*edge);
+        const auto turn_id = edge_data.turn_id; // edge-based graph edge index
+        const auto node_id = *node_from;        // edge-based graph node index
+        const auto name_index = facade.GetNameIndex(node_id);
+        const auto turn_instruction = facade.GetTurnInstructionForEdgeID(turn_id);
+        const extractor::TravelMode travel_mode = facade.GetTravelMode(node_id);
+        const auto classes = facade.GetClassData(node_id);
+
+        const auto geometry_index = facade.GetGeometryIndex(node_id);
+        get_segment_geometry(geometry_index);
+
         BOOST_ASSERT(id_vector.size() > 0);
         BOOST_ASSERT(datasource_vector.size() > 0);
         BOOST_ASSERT(weight_vector.size() == id_vector.size() - 1);
@@ -216,21 +222,14 @@ void annotatePath(const FacadeT &facade,
     }
 
     std::size_t start_index = 0, end_index = 0;
-    std::vector<unsigned> id_vector;
-    std::vector<EdgeWeight> weight_vector;
-    std::vector<EdgeWeight> duration_vector;
-    std::vector<DatasourceID> datasource_vector;
     const auto source_geometry_id = facade.GetGeometryIndex(source_node_id).id;
-    const auto target_geometry_id = facade.GetGeometryIndex(target_node_id).id;
-    const auto is_local_path = source_geometry_id == target_geometry_id && unpacked_path.empty();
+    const auto target_geometry = facade.GetGeometryIndex(target_node_id);
+    const auto is_local_path = source_geometry_id == target_geometry.id && unpacked_path.empty();
+
+    get_segment_geometry(target_geometry);
 
     if (target_traversed_in_reverse)
     {
-        id_vector = facade.GetUncompressedReverseGeometry(target_geometry_id);
-        weight_vector = facade.GetUncompressedReverseWeights(target_geometry_id);
-        duration_vector = facade.GetUncompressedReverseDurations(target_geometry_id);
-        datasource_vector = facade.GetUncompressedReverseDatasources(target_geometry_id);
-
         if (is_local_path)
         {
             start_index =
@@ -246,11 +245,6 @@ void annotatePath(const FacadeT &facade,
             start_index = phantom_node_pair.source_phantom.fwd_segment_position;
         }
         end_index = phantom_node_pair.target_phantom.fwd_segment_position;
-
-        id_vector = facade.GetUncompressedForwardGeometry(target_geometry_id);
-        weight_vector = facade.GetUncompressedForwardWeights(target_geometry_id);
-        duration_vector = facade.GetUncompressedForwardDurations(target_geometry_id);
-        datasource_vector = facade.GetUncompressedForwardDatasources(target_geometry_id);
     }
 
     // Given the following compressed geometry:
@@ -308,24 +302,6 @@ void annotatePath(const FacadeT &facade,
         unpacked_path.front().duration_until_turn =
             std::max(unpacked_path.front().duration_until_turn - source_duration, 0);
     }
-
-    // there is no equivalent to a node-based node in an edge-expanded graph.
-    // two equivalent routes may start (or end) at different node-based edges
-    // as they are added with the offset how much "weight" on the edge
-    // has already been traversed. Depending on offset one needs to remove
-    // the last node.
-    if (unpacked_path.size() > 1)
-    {
-        const std::size_t last_index = unpacked_path.size() - 1;
-        const std::size_t second_to_last_index = last_index - 1;
-
-        if (unpacked_path[last_index].turn_via_node ==
-            unpacked_path[second_to_last_index].turn_via_node)
-        {
-            unpacked_path.pop_back();
-        }
-        BOOST_ASSERT(!unpacked_path.empty());
-    }
 }
 
 template <typename Algorithm>

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -30,7 +30,8 @@ namespace
 // Unrestricted search (Args is const PhantomNodes &):
 //   * use partition.GetQueryLevel to find the node query level based on source and target phantoms
 //   * allow to traverse all cells
-inline LevelID getNodeQueryLevel(const partition::MultiLevelPartitionView &partition,
+template <typename MultiLevelPartition>
+inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
                                  NodeID node,
                                  const PhantomNodes &phantom_nodes)
 {
@@ -54,8 +55,8 @@ inline bool checkParentCellRestriction(CellID, const PhantomNodes &) { return tr
 // Restricted search (Args is LevelID, CellID):
 //   * use the fixed level for queries
 //   * check if the node cell is the same as the specified parent onr
-inline LevelID
-getNodeQueryLevel(const partition::MultiLevelPartitionView &, NodeID, LevelID level, CellID)
+template <typename MultiLevelPartition>
+inline LevelID getNodeQueryLevel(const MultiLevelPartition &, NodeID, LevelID level, CellID)
 {
     return level;
 }
@@ -130,10 +131,10 @@ retrievePackedPathFromHeap(const SearchEngineData<Algorithm>::QueryHeap &forward
     return packed_path;
 }
 
-template <bool DIRECTION, typename... Args>
+template <bool DIRECTION, typename Algorithm, typename... Args>
 void routingStep(const DataFacade<Algorithm> &facade,
-                 SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                 SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                 typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                 typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                  NodeID &middle_node,
                  EdgeWeight &path_upper_bound,
                  const bool force_loop_forward,
@@ -260,11 +261,11 @@ using UnpackedNodes = std::vector<NodeID>;
 using UnpackedEdges = std::vector<EdgeID>;
 using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;
 
-template <typename... Args>
+template <typename Algorithm, typename... Args>
 UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
                     const DataFacade<Algorithm> &facade,
-                    SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                    SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                    typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                    typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                     const bool force_loop_forward,
                     const bool force_loop_reverse,
                     EdgeWeight weight_upper_bound,
@@ -389,10 +390,11 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
 }
 
 // Alias to be compatible with the CH-based search
+template <typename Algorithm>
 inline void search(SearchEngineData<Algorithm> &engine_working_data,
                    const DataFacade<Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                   typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                   typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                    EdgeWeight &weight,
                    std::vector<NodeID> &unpacked_nodes,
                    const bool force_loop_forward,
@@ -442,13 +444,14 @@ void unpackPath(const FacadeT &facade,
     annotatePath(facade, phantom_nodes, unpacked_nodes, unpacked_edges, unpacked_path);
 }
 
-inline double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
-                                 const DataFacade<Algorithm> &facade,
-                                 SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                                 SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                                 const PhantomNode &source_phantom,
-                                 const PhantomNode &target_phantom,
-                                 EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
+template <typename Algorithm>
+double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
+                          const DataFacade<Algorithm> &facade,
+                          typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                          typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                          const PhantomNode &source_phantom,
+                          const PhantomNode &target_phantom,
+                          EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
     forward_heap.Clear();
     reverse_heap.Clear();

include/engine/routing_algorithms/shortest_path.hpp

@@ -1,5 +1,5 @@
-#ifndef SHORTEST_PATH_HPP
-#define SHORTEST_PATH_HPP
+#ifndef OSRM_SHORTEST_PATH_HPP
+#define OSRM_SHORTEST_PATH_HPP
 
 #include "engine/algorithm.hpp"
 #include "engine/routing_algorithms/routing_base.hpp"
@@ -23,4 +23,4 @@ InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_worki
 } // namespace engine
 } // namespace osrm
 
-#endif /* SHORTEST_PATH_HPP */
+#endif /* OSRM_SHORTEST_PATH_HPP */

include/engine/routing_algorithms/shortest_path_impl.hpp

@@ -0,0 +1,463 @@
+#ifndef OSRM_SHORTEST_PATH_IMPL_HPP
+#define OSRM_SHORTEST_PATH_IMPL_HPP
+
+#include "engine/routing_algorithms/shortest_path.hpp"
+
+#include <boost/assert.hpp>
+#include <boost/optional.hpp>
+
+namespace osrm
+{
+namespace engine
+{
+namespace routing_algorithms
+{
+
+namespace
+{
+
+const static constexpr bool DO_NOT_FORCE_LOOP = false;
+
+// allows a uturn at the target_phantom
+// searches source forward/reverse -> target forward/reverse
+template <typename Algorithm>
+void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
+                     const DataFacade<Algorithm> &facade,
+                     typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                     typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                     const bool search_from_forward_node,
+                     const bool search_from_reverse_node,
+                     const bool search_to_forward_node,
+                     const bool search_to_reverse_node,
+                     const PhantomNode &source_phantom,
+                     const PhantomNode &target_phantom,
+                     const int total_weight_to_forward,
+                     const int total_weight_to_reverse,
+                     int &new_total_weight,
+                     std::vector<NodeID> &leg_packed_path)
+{
+    forward_heap.Clear();
+    reverse_heap.Clear();
+    if (search_from_forward_node)
+    {
+        forward_heap.Insert(source_phantom.forward_segment_id.id,
+                            -source_phantom.GetForwardWeightPlusOffset(),
+                            source_phantom.forward_segment_id.id);
+    }
+    if (search_from_reverse_node)
+    {
+        forward_heap.Insert(source_phantom.reverse_segment_id.id,
+                            -source_phantom.GetReverseWeightPlusOffset(),
+                            source_phantom.reverse_segment_id.id);
+    }
+    if (search_to_forward_node)
+    {
+        reverse_heap.Insert(target_phantom.forward_segment_id.id,
+                            target_phantom.GetForwardWeightPlusOffset(),
+                            target_phantom.forward_segment_id.id);
+    }
+    if (search_to_reverse_node)
+    {
+        reverse_heap.Insert(target_phantom.reverse_segment_id.id,
+                            target_phantom.GetReverseWeightPlusOffset(),
+                            target_phantom.reverse_segment_id.id);
+    }
+
+    // this is only relevent if source and target are on the same compressed edge
+    auto is_oneway_source = !(search_from_forward_node && search_from_reverse_node);
+    auto is_oneway_target = !(search_to_forward_node && search_to_reverse_node);
+    // we only enable loops here if we can't search from forward to backward node
+    auto needs_loop_forwards = is_oneway_source && needsLoopForward(source_phantom, target_phantom);
+    auto needs_loop_backwards =
+        is_oneway_target && needsLoopBackwards(source_phantom, target_phantom);
+
+    search(engine_working_data,
+           facade,
+           forward_heap,
+           reverse_heap,
+           new_total_weight,
+           leg_packed_path,
+           needs_loop_forwards,
+           needs_loop_backwards,
+           {source_phantom, target_phantom});
+
+    // if no route is found between two parts of the via-route, the entire route becomes
+    // invalid. Adding to invalid edge weight sadly doesn't return an invalid edge weight. Here
+    // we prevent the possible overflow, faking the addition of infinity + x == infinity
+    if (new_total_weight != INVALID_EDGE_WEIGHT)
+        new_total_weight += std::min(total_weight_to_forward, total_weight_to_reverse);
+}
+
+// searches shortest path between:
+// source forward/reverse -> target forward
+// source forward/reverse -> target reverse
+template <typename Algorithm>
+void search(SearchEngineData<Algorithm> &engine_working_data,
+            const DataFacade<Algorithm> &facade,
+            typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+            typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+            const bool search_from_forward_node,
+            const bool search_from_reverse_node,
+            const bool search_to_forward_node,
+            const bool search_to_reverse_node,
+            const PhantomNode &source_phantom,
+            const PhantomNode &target_phantom,
+            const int total_weight_to_forward,
+            const int total_weight_to_reverse,
+            int &new_total_weight_to_forward,
+            int &new_total_weight_to_reverse,
+            std::vector<NodeID> &leg_packed_path_forward,
+            std::vector<NodeID> &leg_packed_path_reverse)
+{
+    if (search_to_forward_node)
+    {
+        forward_heap.Clear();
+        reverse_heap.Clear();
+        reverse_heap.Insert(target_phantom.forward_segment_id.id,
+                            target_phantom.GetForwardWeightPlusOffset(),
+                            target_phantom.forward_segment_id.id);
+
+        if (search_from_forward_node)
+        {
+            forward_heap.Insert(source_phantom.forward_segment_id.id,
+                                total_weight_to_forward -
+                                    source_phantom.GetForwardWeightPlusOffset(),
+                                source_phantom.forward_segment_id.id);
+        }
+        if (search_from_reverse_node)
+        {
+            forward_heap.Insert(source_phantom.reverse_segment_id.id,
+                                total_weight_to_reverse -
+                                    source_phantom.GetReverseWeightPlusOffset(),
+                                source_phantom.reverse_segment_id.id);
+        }
+
+        search(engine_working_data,
+               facade,
+               forward_heap,
+               reverse_heap,
+               new_total_weight_to_forward,
+               leg_packed_path_forward,
+               needsLoopForward(source_phantom, target_phantom),
+               routing_algorithms::DO_NOT_FORCE_LOOP,
+               {source_phantom, target_phantom});
+    }
+
+    if (search_to_reverse_node)
+    {
+        forward_heap.Clear();
+        reverse_heap.Clear();
+        reverse_heap.Insert(target_phantom.reverse_segment_id.id,
+                            target_phantom.GetReverseWeightPlusOffset(),
+                            target_phantom.reverse_segment_id.id);
+        if (search_from_forward_node)
+        {
+            forward_heap.Insert(source_phantom.forward_segment_id.id,
+                                total_weight_to_forward -
+                                    source_phantom.GetForwardWeightPlusOffset(),
+                                source_phantom.forward_segment_id.id);
+        }
+        if (search_from_reverse_node)
+        {
+            forward_heap.Insert(source_phantom.reverse_segment_id.id,
+                                total_weight_to_reverse -
+                                    source_phantom.GetReverseWeightPlusOffset(),
+                                source_phantom.reverse_segment_id.id);
+        }
+
+        search(engine_working_data,
+               facade,
+               forward_heap,
+               reverse_heap,
+               new_total_weight_to_reverse,
+               leg_packed_path_reverse,
+               routing_algorithms::DO_NOT_FORCE_LOOP,
+               needsLoopBackwards(source_phantom, target_phantom),
+               {source_phantom, target_phantom});
+    }
+}
+
+template <typename Algorithm>
+void unpackLegs(const DataFacade<Algorithm> &facade,
+                const std::vector<PhantomNodes> &phantom_nodes_vector,
+                const std::vector<NodeID> &total_packed_path,
+                const std::vector<std::size_t> &packed_leg_begin,
+                const EdgeWeight shortest_path_weight,
+                InternalRouteResult &raw_route_data)
+{
+    raw_route_data.unpacked_path_segments.resize(packed_leg_begin.size() - 1);
+
+    raw_route_data.shortest_path_weight = shortest_path_weight;
+
+    for (const auto current_leg : util::irange<std::size_t>(0UL, packed_leg_begin.size() - 1))
+    {
+        auto leg_begin = total_packed_path.begin() + packed_leg_begin[current_leg];
+        auto leg_end = total_packed_path.begin() + packed_leg_begin[current_leg + 1];
+        const auto &unpack_phantom_node_pair = phantom_nodes_vector[current_leg];
+        unpackPath(facade,
+                   leg_begin,
+                   leg_end,
+                   unpack_phantom_node_pair,
+                   raw_route_data.unpacked_path_segments[current_leg]);
+
+        raw_route_data.source_traversed_in_reverse.push_back(
+            (*leg_begin != phantom_nodes_vector[current_leg].source_phantom.forward_segment_id.id));
+        raw_route_data.target_traversed_in_reverse.push_back(
+            (*std::prev(leg_end) !=
+             phantom_nodes_vector[current_leg].target_phantom.forward_segment_id.id));
+    }
+}
+}
+
+template <typename Algorithm>
+InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
+                                       const DataFacade<Algorithm> &facade,
+                                       const std::vector<PhantomNodes> &phantom_nodes_vector,
+                                       const boost::optional<bool> continue_straight_at_waypoint)
+{
+    InternalRouteResult raw_route_data;
+    raw_route_data.segment_end_coordinates = phantom_nodes_vector;
+    const bool allow_uturn_at_waypoint =
+        !(continue_straight_at_waypoint ? *continue_straight_at_waypoint
+                                        : facade.GetContinueStraightDefault());
+
+    engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
+
+    auto &forward_heap = *engine_working_data.forward_heap_1;
+    auto &reverse_heap = *engine_working_data.reverse_heap_1;
+
+    int total_weight_to_forward = 0;
+    int total_weight_to_reverse = 0;
+    bool search_from_forward_node =
+        phantom_nodes_vector.front().source_phantom.IsValidForwardSource();
+    bool search_from_reverse_node =
+        phantom_nodes_vector.front().source_phantom.IsValidReverseSource();
+
+    std::vector<NodeID> prev_packed_leg_to_forward;
+    std::vector<NodeID> prev_packed_leg_to_reverse;
+
+    std::vector<NodeID> total_packed_path_to_forward;
+    std::vector<std::size_t> packed_leg_to_forward_begin;
+    std::vector<NodeID> total_packed_path_to_reverse;
+    std::vector<std::size_t> packed_leg_to_reverse_begin;
+
+    std::size_t current_leg = 0;
+    // this implements a dynamic program that finds the shortest route through
+    // a list of vias
+    for (const auto &phantom_node_pair : phantom_nodes_vector)
+    {
+        int new_total_weight_to_forward = INVALID_EDGE_WEIGHT;
+        int new_total_weight_to_reverse = INVALID_EDGE_WEIGHT;
+
+        std::vector<NodeID> packed_leg_to_forward;
+        std::vector<NodeID> packed_leg_to_reverse;
+
+        const auto &source_phantom = phantom_node_pair.source_phantom;
+        const auto &target_phantom = phantom_node_pair.target_phantom;
+
+        bool search_to_forward_node = target_phantom.IsValidForwardTarget();
+        bool search_to_reverse_node = target_phantom.IsValidReverseTarget();
+
+        BOOST_ASSERT(!search_from_forward_node || source_phantom.IsValidForwardSource());
+        BOOST_ASSERT(!search_from_reverse_node || source_phantom.IsValidReverseSource());
+
+        if (search_to_reverse_node || search_to_forward_node)
+        {
+            if (allow_uturn_at_waypoint)
+            {
+                searchWithUTurn(engine_working_data,
+                                facade,
+                                forward_heap,
+                                reverse_heap,
+                                search_from_forward_node,
+                                search_from_reverse_node,
+                                search_to_forward_node,
+                                search_to_reverse_node,
+                                source_phantom,
+                                target_phantom,
+                                total_weight_to_forward,
+                                total_weight_to_reverse,
+                                new_total_weight_to_forward,
+                                packed_leg_to_forward);
+                // if only the reverse node is valid (e.g. when using the match plugin) we
+                // actually need to move
+                if (!target_phantom.IsValidForwardTarget())
+                {
+                    BOOST_ASSERT(target_phantom.IsValidReverseTarget());
+                    new_total_weight_to_reverse = new_total_weight_to_forward;
+                    packed_leg_to_reverse = std::move(packed_leg_to_forward);
+                    new_total_weight_to_forward = INVALID_EDGE_WEIGHT;
+
+                    // (*)
+                    //
+                    //   Below we have to check if new_total_weight_to_forward is invalid.
+                    //   This prevents use-after-move on packed_leg_to_forward.
+                }
+                else if (target_phantom.IsValidReverseTarget())
+                {
+                    new_total_weight_to_reverse = new_total_weight_to_forward;
+                    packed_leg_to_reverse = packed_leg_to_forward;
+                }
+            }
+            else
+            {
+                search(engine_working_data,
+                       facade,
+                       forward_heap,
+                       reverse_heap,
+                       search_from_forward_node,
+                       search_from_reverse_node,
+                       search_to_forward_node,
+                       search_to_reverse_node,
+                       source_phantom,
+                       target_phantom,
+                       total_weight_to_forward,
+                       total_weight_to_reverse,
+                       new_total_weight_to_forward,
+                       new_total_weight_to_reverse,
+                       packed_leg_to_forward,
+                       packed_leg_to_reverse);
+            }
+        }
+
+        // Note: To make sure we do not access the moved-from packed_leg_to_forward
+        // we guard its access by a check for invalid edge weight. See  (*) above.
+
+        // No path found for both target nodes?
+        if ((INVALID_EDGE_WEIGHT == new_total_weight_to_forward) &&
+            (INVALID_EDGE_WEIGHT == new_total_weight_to_reverse))
+        {
+            return raw_route_data;
+        }
+
+        // we need to figure out how the new legs connect to the previous ones
+        if (current_leg > 0)
+        {
+            bool forward_to_forward =
+                (new_total_weight_to_forward != INVALID_EDGE_WEIGHT) &&
+                packed_leg_to_forward.front() == source_phantom.forward_segment_id.id;
+            bool reverse_to_forward =
+                (new_total_weight_to_forward != INVALID_EDGE_WEIGHT) &&
+                packed_leg_to_forward.front() == source_phantom.reverse_segment_id.id;
+            bool forward_to_reverse =
+                (new_total_weight_to_reverse != INVALID_EDGE_WEIGHT) &&
+                packed_leg_to_reverse.front() == source_phantom.forward_segment_id.id;
+            bool reverse_to_reverse =
+                (new_total_weight_to_reverse != INVALID_EDGE_WEIGHT) &&
+                packed_leg_to_reverse.front() == source_phantom.reverse_segment_id.id;
+
+            BOOST_ASSERT(!forward_to_forward || !reverse_to_forward);
+            BOOST_ASSERT(!forward_to_reverse || !reverse_to_reverse);
+
+            // in this case we always need to copy
+            if (forward_to_forward && forward_to_reverse)
+            {
+                // in this case we copy the path leading to the source forward node
+                // and change the case
+                total_packed_path_to_reverse = total_packed_path_to_forward;
+                packed_leg_to_reverse_begin = packed_leg_to_forward_begin;
+                forward_to_reverse = false;
+                reverse_to_reverse = true;
+            }
+            else if (reverse_to_forward && reverse_to_reverse)
+            {
+                total_packed_path_to_forward = total_packed_path_to_reverse;
+                packed_leg_to_forward_begin = packed_leg_to_reverse_begin;
+                reverse_to_forward = false;
+                forward_to_forward = true;
+            }
+            BOOST_ASSERT(!forward_to_forward || !forward_to_reverse);
+            BOOST_ASSERT(!reverse_to_forward || !reverse_to_reverse);
+
+            // in this case we just need to swap to regain the correct mapping
+            if (reverse_to_forward || forward_to_reverse)
+            {
+                total_packed_path_to_forward.swap(total_packed_path_to_reverse);
+                packed_leg_to_forward_begin.swap(packed_leg_to_reverse_begin);
+            }
+        }
+
+        if (new_total_weight_to_forward != INVALID_EDGE_WEIGHT)
+        {
+            BOOST_ASSERT(target_phantom.IsValidForwardTarget());
+
+            packed_leg_to_forward_begin.push_back(total_packed_path_to_forward.size());
+            total_packed_path_to_forward.insert(total_packed_path_to_forward.end(),
+                                                packed_leg_to_forward.begin(),
+                                                packed_leg_to_forward.end());
+            search_from_forward_node = true;
+        }
+        else
+        {
+            total_packed_path_to_forward.clear();
+            packed_leg_to_forward_begin.clear();
+            search_from_forward_node = false;
+        }
+
+        if (new_total_weight_to_reverse != INVALID_EDGE_WEIGHT)
+        {
+            BOOST_ASSERT(target_phantom.IsValidReverseTarget());
+
+            packed_leg_to_reverse_begin.push_back(total_packed_path_to_reverse.size());
+            total_packed_path_to_reverse.insert(total_packed_path_to_reverse.end(),
+                                                packed_leg_to_reverse.begin(),
+                                                packed_leg_to_reverse.end());
+            search_from_reverse_node = true;
+        }
+        else
+        {
+            total_packed_path_to_reverse.clear();
+            packed_leg_to_reverse_begin.clear();
+            search_from_reverse_node = false;
+        }
+
+        prev_packed_leg_to_forward = std::move(packed_leg_to_forward);
+        prev_packed_leg_to_reverse = std::move(packed_leg_to_reverse);
+
+        total_weight_to_forward = new_total_weight_to_forward;
+        total_weight_to_reverse = new_total_weight_to_reverse;
+
+        ++current_leg;
+    }
+
+    BOOST_ASSERT(total_weight_to_forward != INVALID_EDGE_WEIGHT ||
+                 total_weight_to_reverse != INVALID_EDGE_WEIGHT);
+
+    // We make sure the fastest route is always in packed_legs_to_forward
+    if (total_weight_to_forward < total_weight_to_reverse ||
+        (total_weight_to_forward == total_weight_to_reverse &&
+         total_packed_path_to_forward.size() < total_packed_path_to_reverse.size()))
+    {
+        // insert sentinel
+        packed_leg_to_forward_begin.push_back(total_packed_path_to_forward.size());
+        BOOST_ASSERT(packed_leg_to_forward_begin.size() == phantom_nodes_vector.size() + 1);
+
+        unpackLegs(facade,
+                   phantom_nodes_vector,
+                   total_packed_path_to_forward,
+                   packed_leg_to_forward_begin,
+                   total_weight_to_forward,
+                   raw_route_data);
+    }
+    else
+    {
+        // insert sentinel
+        packed_leg_to_reverse_begin.push_back(total_packed_path_to_reverse.size());
+        BOOST_ASSERT(packed_leg_to_reverse_begin.size() == phantom_nodes_vector.size() + 1);
+
+        unpackLegs(facade,
+                   phantom_nodes_vector,
+                   total_packed_path_to_reverse,
+                   packed_leg_to_reverse_begin,
+                   total_weight_to_reverse,
+                   raw_route_data);
+    }
+
+    return raw_route_data;
+}
+
+} // namespace routing_algorithms
+} // namespace engine
+} // namespace osrm
+
+#endif /* OSRM_SHORTEST_PATH_IMPL_HPP */

include/engine/routing_algorithms/tile_turns.hpp

@@ -3,7 +3,6 @@
 
 #include "engine/algorithm.hpp"
 #include "engine/datafacade.hpp"
-#include "engine/datafacade/datafacade_base.hpp"
 
 #include "util/coordinate.hpp"
 #include "util/typedefs.hpp"

include/engine/search_engine_data.hpp

@@ -1,12 +1,12 @@
 #ifndef SEARCH_ENGINE_DATA_HPP
 #define SEARCH_ENGINE_DATA_HPP
 
-#include <boost/thread/tss.hpp>
-
 #include "engine/algorithm.hpp"
 #include "util/query_heap.hpp"
 #include "util/typedefs.hpp"
 
+#include <boost/thread/tss.hpp>
+
 namespace osrm
 {
 namespace engine
@@ -37,7 +37,6 @@ template <> struct SearchEngineData<routing_algorithms::ch::Algorithm>
 {
     using QueryHeap = util::
         QueryHeap<NodeID, NodeID, EdgeWeight, HeapData, util::UnorderedMapStorage<NodeID, int>>;
-    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
 
     using ManyToManyQueryHeap = util::QueryHeap<NodeID,
                                                 NodeID,
@@ -45,6 +44,7 @@ template <> struct SearchEngineData<routing_algorithms::ch::Algorithm>
                                                 ManyToManyHeapData,
                                                 util::UnorderedMapStorage<NodeID, int>>;
 
+    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
     using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;
 
     static SearchEngineHeapPtr forward_heap_1;
@@ -106,7 +106,6 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
                                                 util::UnorderedMapStorage<NodeID, int>>;
 
     using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
-
     using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;
 
     static SearchEngineHeapPtr forward_heap_1;

include/extractor/compressed_edge_container.hpp

@@ -10,6 +10,8 @@
 #include <string>
 #include <vector>
 
+#include <boost/optional.hpp>
+
 namespace osrm
 {
 namespace extractor
@@ -36,7 +38,11 @@ class CompressedEdgeContainer
                       const EdgeWeight weight1,
                       const EdgeWeight weight2,
                       const EdgeDuration duration1,
-                      const EdgeDuration duration2);
+                      const EdgeDuration duration2,
+                      // node-penalties can be added before/or after the traversal of an edge which
+                      // depends on whether we traverse the link forwards or backwards.
+                      const boost::optional<EdgeWeight> node_weight_penalty = boost::none,
+                      const boost::optional<EdgeDuration> node_duration_penalty = boost::none);
 
     void AddUncompressedEdge(const EdgeID edge_id,
                              const NodeID target_node,

include/extractor/conditional_turn_penalty.hpp

@@ -0,0 +1,28 @@
+#ifndef OSRM_EXTRACTOR_CONDITIONAL_TURN_PENALTY_HPP_
+#define OSRM_EXTRACTOR_CONDITIONAL_TURN_PENALTY_HPP_
+
+#include "util/coordinate.hpp"
+#include "util/opening_hours.hpp"
+#include <cstdint>
+#include <vector>
+
+#include <type_traits>
+
+namespace osrm
+
+{
+namespace extractor
+{
+
+struct ConditionalTurnPenalty
+{
+    // offset into the sequential list of turn penalties (see TurnIndexBlock for reference);
+    std::uint64_t turn_offset;
+    util::Coordinate location;
+    std::vector<util::OpeningHours> conditions;
+};
+
+} // namespace extractor
+} // namespace osrm
+
+#endif // OSRM_EXTRACTOR_CONDITIONAL_TURN_PENALTY_HPP_

include/extractor/edge_based_graph_factory.hpp

@@ -4,6 +4,7 @@
 #define EDGE_BASED_GRAPH_FACTORY_HPP_
 
 #include "extractor/compressed_edge_container.hpp"
+#include "extractor/conditional_turn_penalty.hpp"
 #include "extractor/edge_based_edge.hpp"
 #include "extractor/edge_based_node_segment.hpp"
 #include "extractor/extraction_turn.hpp"
@@ -16,7 +17,7 @@
 #include "extractor/packed_osm_ids.hpp"
 #include "extractor/profile_properties.hpp"
 #include "extractor/query_node.hpp"
-#include "extractor/restriction_map.hpp"
+#include "extractor/restriction_index.hpp"
 #include "extractor/way_restriction_map.hpp"
 
 #include "util/concurrent_id_map.hpp"
@@ -41,11 +42,6 @@
 #include <unordered_set>
 #include <vector>
 
-#include <boost/filesystem/fstream.hpp>
-
-#include <tbb/concurrent_unordered_map.h>
-#include <tbb/concurrent_vector.h>
-
 namespace osrm
 {
 namespace extractor
@@ -92,7 +88,9 @@ class EdgeBasedGraphFactory
              const std::string &turn_duration_penalties_filename,
              const std::string &turn_penalties_index_filename,
              const std::string &cnbg_ebg_mapping_path,
+             const std::string &conditional_penalties_filename,
              const RestrictionMap &node_restriction_map,
+             const ConditionalRestrictionMap &conditional_restriction_map,
              const WayRestrictionMap &way_restriction_map);
 
     // The following get access functions destroy the content in the factory
@@ -124,6 +122,18 @@ class EdgeBasedGraphFactory
   private:
     using EdgeData = util::NodeBasedDynamicGraph::EdgeData;
 
+    struct Conditional
+    {
+        // the edge based nodes allow for a unique identification of conditionals
+        NodeID from_node;
+        NodeID to_node;
+        ConditionalTurnPenalty penalty;
+    };
+
+    // assign the correct index to the penalty value stored in the conditional
+    std::vector<ConditionalTurnPenalty>
+    IndexConditionals(std::vector<Conditional> &&conditionals) const;
+
     //! maps index from m_edge_based_node_list to ture/false if the node is an entry point to the
     //! graph
     std::vector<bool> m_edge_based_node_is_startpoint;
@@ -173,7 +183,9 @@ class EdgeBasedGraphFactory
                                    const std::string &turn_weight_penalties_filename,
                                    const std::string &turn_duration_penalties_filename,
                                    const std::string &turn_penalties_index_filename,
+                                   const std::string &conditional_turn_penalties_filename,
                                    const RestrictionMap &node_restriction_map,
+                                   const ConditionalRestrictionMap &conditional_restriction_map,
                                    const WayRestrictionMap &way_restriction_map);
 
     NBGToEBG InsertEdgeBasedNode(const NodeID u, const NodeID v);

include/extractor/extraction_containers.hpp

@@ -27,7 +27,6 @@ class ExtractionContainers
     void PrepareEdges(ScriptingEnvironment &scripting_environment);
 
     void WriteNodes(storage::io::FileWriter &file_out) const;
-    void WriteConditionalRestrictions(const std::string &restrictions_file_name);
     void WriteEdges(storage::io::FileWriter &file_out) const;
     void WriteCharData(const std::string &file_name);
 
@@ -40,7 +39,7 @@ class ExtractionContainers
     using NameOffsets = std::vector<unsigned>;
 
     std::vector<OSMNodeID> barrier_nodes;
-    std::vector<OSMNodeID> traffic_lights;
+    std::vector<OSMNodeID> traffic_signals;
     NodeIDVector used_node_id_list;
     NodeVector all_nodes_list;
     EdgeVector all_edges_list;
@@ -65,7 +64,6 @@ class ExtractionContainers
 
     void PrepareData(ScriptingEnvironment &scripting_environment,
                      const std::string &osrm_path,
-                     const std::string &restrictions_file_name,
                      const std::string &names_data_path);
 };
 }

include/extractor/extraction_turn.hpp

@@ -22,6 +22,14 @@ struct ExtractionTurn
     {
     }
 
+    ExtractionTurn(const bool has_traffic_light = false)
+        : angle(0), turn_type(guidance::TurnType::NoTurn),
+          direction_modifier(guidance::DirectionModifier::Straight),
+          has_traffic_light(has_traffic_light), weight(0.), duration(0.), source_restricted(false),
+          target_restricted(false)
+    {
+    }
+
     const double angle;
     const guidance::TurnType::Enum turn_type;
     const guidance::DirectionModifier::Enum direction_modifier;

include/extractor/extractor.hpp

@@ -56,7 +56,9 @@ class Extractor
   private:
     ExtractorConfig config;
 
-    std::tuple<guidance::LaneDescriptionMap, std::vector<TurnRestriction>>
+    std::tuple<guidance::LaneDescriptionMap,
+               std::vector<TurnRestriction>,
+               std::vector<ConditionalTurnRestriction>>
     ParseOSMData(ScriptingEnvironment &scripting_environment, const unsigned number_of_threads);
 
     std::pair<std::size_t, EdgeID>
@@ -70,6 +72,7 @@ class Extractor
                            util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
                            const std::string &intersection_class_output_file,
                            std::vector<TurnRestriction> &turn_restrictions,
+                           std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
                            guidance::LaneDescriptionMap &turn_lane_map);
     void FindComponents(unsigned max_edge_id,
                         const util::DeallocatingVector<EdgeBasedEdge> &input_edge_list,
@@ -89,6 +92,10 @@ class Extractor
     static void WriteCompressedNodeBasedGraph(const std::string &path,
                                               const util::NodeBasedDynamicGraph &graph,
                                               const std::vector<util::Coordinate> &coordiantes);
+
+    void WriteConditionalRestrictions(
+        const std::string &path,
+        std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions);
 };
 }
 }

include/extractor/graph_compressor.hpp

@@ -1,6 +1,7 @@
 #ifndef GEOMETRY_COMPRESSOR_HPP
 #define GEOMETRY_COMPRESSOR_HPP
 
+#include "extractor/scripting_environment.hpp"
 #include "util/typedefs.hpp"
 
 #include "util/node_based_graph.hpp"
@@ -24,7 +25,9 @@ class GraphCompressor
   public:
     void Compress(const std::unordered_set<NodeID> &barrier_nodes,
                   const std::unordered_set<NodeID> &traffic_lights,
+                  ScriptingEnvironment &scripting_environment,
                   std::vector<TurnRestriction> &turn_restrictions,
+                  std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
                   util::NodeBasedDynamicGraph &graph,
                   CompressedEdgeContainer &geometry_compressor);
 

include/extractor/guidance/intersection_generator.hpp

@@ -6,7 +6,7 @@
 #include "extractor/guidance/intersection.hpp"
 #include "extractor/guidance/intersection_normalization_operation.hpp"
 #include "extractor/query_node.hpp"
-#include "extractor/restriction_map.hpp"
+#include "extractor/restriction_index.hpp"
 #include "util/attributes.hpp"
 #include "util/node_based_graph.hpp"
 #include "util/typedefs.hpp"
@@ -116,14 +116,6 @@ class IntersectionGenerator
 
     // own state, used to find the correct coordinates along a road
     const CoordinateExtractor coordinate_extractor;
-
-    // check turn restrictions to find a node that is the only allowed target when coming from a
-    // node to an intersection
-    //     d
-    //     |
-    // a - b - c  and `only_straight_on ab | bc would return `c` for `a,b`
-    boost::optional<NodeID> GetOnlyAllowedTurnIfExistent(const NodeID coming_from_node,
-                                                         const NodeID node_at_intersection) const;
 };
 
 } // namespace guidance

include/extractor/guidance/turn_analysis.hpp

@@ -14,7 +14,7 @@
 #include "extractor/guidance/turn_classification.hpp"
 #include "extractor/guidance/turn_handler.hpp"
 #include "extractor/query_node.hpp"
-#include "extractor/restriction_map.hpp"
+#include "extractor/restriction_index.hpp"
 #include "extractor/suffix_table.hpp"
 
 #include "util/attributes.hpp"

include/extractor/guidance/turn_instruction.hpp

@@ -199,7 +199,10 @@ inline bool leavesRoundabout(const extractor::guidance::TurnInstruction instruct
 
 inline bool staysOnRoundabout(const extractor::guidance::TurnInstruction instruction)
 {
-    return instruction.type == extractor::guidance::TurnType::StayOnRoundabout;
+    return instruction.type == extractor::guidance::TurnType::StayOnRoundabout ||
+           instruction.type == extractor::guidance::TurnType::EnterRoundaboutAtExit ||
+           instruction.type == extractor::guidance::TurnType::EnterRotaryAtExit ||
+           instruction.type == extractor::guidance::TurnType::EnterRoundaboutIntersectionAtExit;
 }
 
 // Silent Turn Instructions are not to be mentioned to the outside world but

include/extractor/profile_properties.hpp

@@ -83,7 +83,8 @@ struct ProfileProperties
     std::string GetClassName(std::size_t index) const
     {
         BOOST_ASSERT(index <= MAX_CLASS_INDEX);
-        return std::string(class_names[index]);
+        const auto &name_it = std::begin(class_names) + index;
+        return std::string(*name_it);
     }
 
     double GetWeightMultiplier() const { return std::pow(10., weight_precision); }

include/extractor/restriction_compressor.hpp

@@ -1,6 +1,7 @@
 #ifndef OSRM_EXTRACTOR_RESTRICTION_COMPRESSOR_HPP_
 #define OSRM_EXTRACTOR_RESTRICTION_COMPRESSOR_HPP_
 
+#include "extractor/restriction.hpp"
 #include "util/typedefs.hpp"
 
 #include <boost/unordered_map.hpp>
@@ -26,7 +27,8 @@ struct TurnRestriction;
 class RestrictionCompressor
 {
   public:
-    RestrictionCompressor(std::vector<TurnRestriction> &restrictions);
+    RestrictionCompressor(std::vector<TurnRestriction> &restrictions,
+                          std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions);
 
     // account for the compression of `from-via-to` into `from-to`
     void Compress(const NodeID from, const NodeID via, const NodeID to);

include/extractor/restriction_filter.hpp

@@ -14,8 +14,9 @@ namespace extractor
 // To avoid handling invalid restrictions / creating unnecessary duplicate nodes for via-ways, we do
 // a pre-flight check for restrictions and remove all invalid restrictions from the data. Use as
 // `restrictions = removeInvalidRestrictions(std::move(restrictions))`
-std::vector<TurnRestriction> removeInvalidRestrictions(std::vector<TurnRestriction>,
-                                                       const util::NodeBasedDynamicGraph &);
+std::vector<ConditionalTurnRestriction>
+removeInvalidRestrictions(std::vector<ConditionalTurnRestriction>,
+                          const util::NodeBasedDynamicGraph &);
 
 } // namespace extractor
 } // namespace osrm

include/extractor/restriction_index.hpp

@@ -0,0 +1,101 @@
+#ifndef OSRM_EXTRACTOR_RESTRICTION_INDEX_HPP_
+#define OSRM_EXTRACTOR_RESTRICTION_INDEX_HPP_
+
+#include "extractor/restriction.hpp"
+#include "util/typedefs.hpp"
+
+#include <boost/unordered_map.hpp>
+
+#include <utility>
+#include <vector>
+
+namespace osrm
+{
+namespace extractor
+{
+
+// allows easy check for whether a node intersection is present at a given intersection
+template <typename restriction_type> class RestrictionIndex
+{
+  public:
+    using value_type = restriction_type;
+
+    template <typename extractor_type>
+    RestrictionIndex(std::vector<restriction_type> &restrictions, extractor_type extractor);
+
+    bool IsIndexed(NodeID first, NodeID second) const;
+
+    auto Restrictions(NodeID first, NodeID second) const
+    {
+        return restriction_hash.equal_range(std::make_pair(first, second));
+    };
+
+    auto Size() const { return restriction_hash.size(); }
+
+  private:
+    boost::unordered_multimap<std::pair<NodeID, NodeID>, restriction_type *> restriction_hash;
+};
+
+template <typename restriction_type>
+template <typename extractor_type>
+RestrictionIndex<restriction_type>::RestrictionIndex(std::vector<restriction_type> &restrictions,
+                                                     extractor_type extractor)
+{
+    // build a multi-map
+    for (auto &restriction : restrictions)
+        restriction_hash.insert(std::make_pair(extractor(restriction), &restriction));
+}
+
+template <typename restriction_type>
+bool RestrictionIndex<restriction_type>::IsIndexed(const NodeID first, const NodeID second) const
+{
+    return restriction_hash.count(std::make_pair(first, second));
+}
+
+struct IndexNodeByFromAndVia
+{
+    std::pair<NodeID, NodeID> operator()(const TurnRestriction &restriction)
+    {
+        const auto &node = restriction.AsNodeRestriction();
+        return std::make_pair(node.from, node.via);
+    };
+};
+
+// check wheter a turn is restricted within a restriction_index
+template <typename restriction_map_type>
+std::pair<bool, typename restriction_map_type::value_type *>
+isRestricted(const NodeID from,
+             const NodeID via,
+             const NodeID to,
+             const restriction_map_type &restriction_map)
+{
+    const auto range = restriction_map.Restrictions(from, via);
+
+    // check if a given node_restriction is targeting node
+    const auto to_is_restricted = [to](const auto &pair) {
+        const auto &restriction = *pair.second;
+        if (restriction.Type() == RestrictionType::NODE_RESTRICTION)
+        {
+            auto const &as_node = restriction.AsNodeRestriction();
+            auto const restricted = restriction.is_only ? (to != as_node.to) : (to == as_node.to);
+
+            return restricted;
+        }
+        return false;
+    };
+
+    auto itr = std::find_if(range.first, range.second, to_is_restricted);
+
+    if (itr != range.second)
+        return {true, itr->second};
+    else
+        return {false, NULL};
+}
+
+using RestrictionMap = RestrictionIndex<TurnRestriction>;
+using ConditionalRestrictionMap = RestrictionIndex<ConditionalTurnRestriction>;
+
+} // namespace extractor
+} // namespace osrm
+
+#endif // OSRM_EXTRACTOR_RESTRICTION_INDEX_HPP_

include/extractor/restriction_map.hpp

@@ -1,110 +0,0 @@
-#ifndef RESTRICTION_MAP_HPP
-#define RESTRICTION_MAP_HPP
-
-#include "extractor/edge_based_edge.hpp"
-#include "extractor/restriction.hpp"
-#include "util/std_hash.hpp"
-#include "util/typedefs.hpp"
-
-#include <boost/assert.hpp>
-
-#include <memory>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-namespace osrm
-{
-namespace extractor
-{
-
-struct RestrictionSource
-{
-    NodeID start_node;
-    NodeID via_node;
-
-    RestrictionSource(NodeID start, NodeID via) : start_node(start), via_node(via) {}
-
-    friend inline bool operator==(const RestrictionSource &lhs, const RestrictionSource &rhs)
-    {
-        return (lhs.start_node == rhs.start_node && lhs.via_node == rhs.via_node);
-    }
-};
-
-struct RestrictionTarget
-{
-    NodeID target_node;
-    bool is_only;
-
-    explicit RestrictionTarget(NodeID target, bool only) : target_node(target), is_only(only) {}
-
-    friend inline bool operator==(const RestrictionTarget &lhs, const RestrictionTarget &rhs)
-    {
-        return (lhs.target_node == rhs.target_node && lhs.is_only == rhs.is_only);
-    }
-};
-}
-}
-
-namespace std
-{
-template <> struct hash<osrm::extractor::RestrictionSource>
-{
-    size_t operator()(const osrm::extractor::RestrictionSource &r_source) const
-    {
-        return hash_val(r_source.start_node, r_source.via_node);
-    }
-};
-
-template <> struct hash<osrm::extractor::RestrictionTarget>
-{
-    size_t operator()(const osrm::extractor::RestrictionTarget &r_target) const
-    {
-        return hash_val(r_target.target_node, r_target.is_only);
-    }
-};
-}
-
-namespace osrm
-{
-namespace extractor
-{
-/**
-    \brief Efficent look up if an edge is the start + via node of a TurnRestriction
-    EdgeBasedEdgeFactory decides by it if edges are inserted or geometry is compressed
-*/
-class RestrictionMap
-{
-  public:
-    RestrictionMap() : m_count(0) {}
-    RestrictionMap(const std::vector<TurnRestriction> &restriction_list);
-
-    bool IsViaNode(const NodeID node) const;
-
-    // Check if edge (u, v) is the start of any turn restriction.
-    // If so returns id of first target node.
-    NodeID CheckForEmanatingIsOnlyTurn(const NodeID node_u, const NodeID node_v) const;
-    // Checks if turn <u,v,w> is actually a turn restriction.
-    bool
-    CheckIfTurnIsRestricted(const NodeID node_u, const NodeID node_v, const NodeID node_w) const;
-
-    std::size_t size() const { return m_count; }
-
-  private:
-    // check of node is the start of any restriction
-    bool IsSourceNode(const NodeID node) const;
-
-    using EmanatingRestrictionsVector = std::vector<RestrictionTarget>;
-
-    std::size_t m_count;
-    //! index -> list of (target, isOnly)
-    std::vector<EmanatingRestrictionsVector> m_restriction_bucket_list;
-    //! maps (start, via) -> bucket index
-    std::unordered_map<RestrictionSource, unsigned> m_restriction_map;
-    std::unordered_set<NodeID> m_restriction_start_nodes;
-    std::unordered_set<NodeID> m_no_turn_via_node_set;
-};
-}
-}
-
-#endif // RESTRICTION_MAP_HPP

include/extractor/serialization.hpp

@@ -1,6 +1,7 @@
 #ifndef OSRM_EXTRACTOR_IO_HPP
 #define OSRM_EXTRACTOR_IO_HPP
 
+#include "conditional_turn_penalty.hpp"
 #include "extractor/datasources.hpp"
 #include "extractor/intersection_bearings_container.hpp"
 #include "extractor/nbg_to_ebg.hpp"
@@ -166,7 +167,9 @@ inline void write(storage::io::FileWriter &writer, const WayRestriction &restric
 inline void read(storage::io::FileReader &reader, TurnRestriction &restriction)
 {
     reader.ReadInto(restriction.is_only);
-    if (restriction.Type() == RestrictionType::WAY_RESTRICTION)
+    std::uint32_t restriction_type;
+    reader.ReadInto(restriction_type);
+    if (restriction_type == RestrictionType::WAY_RESTRICTION)
     {
         WayRestriction way_restriction;
         read(reader, way_restriction);
@@ -174,7 +177,7 @@ inline void read(storage::io::FileReader &reader, TurnRestriction &restriction)
     }
     else
     {
-        BOOST_ASSERT(restriction.Type() == RestrictionType::NODE_RESTRICTION);
+        BOOST_ASSERT(restriction_type == RestrictionType::NODE_RESTRICTION);
         NodeRestriction node_restriction;
         read(reader, node_restriction);
         restriction.node_or_way = std::move(node_restriction);
@@ -184,6 +187,8 @@ inline void read(storage::io::FileReader &reader, TurnRestriction &restriction)
 inline void write(storage::io::FileWriter &writer, const TurnRestriction &restriction)
 {
     writer.WriteOne(restriction.is_only);
+    const std::uint32_t restriction_type = restriction.Type();
+    writer.WriteOne(restriction_type);
     if (restriction.Type() == RestrictionType::WAY_RESTRICTION)
     {
         write(writer, mapbox::util::get<WayRestriction>(restriction.node_or_way));
@@ -269,6 +274,54 @@ inline void write(storage::io::FileWriter &writer,
     };
     std::for_each(restrictions.begin(), restrictions.end(), write_restriction);
 }
+
+inline void read(storage::io::FileReader &reader, ConditionalTurnPenalty &turn_penalty)
+{
+    reader.ReadInto(turn_penalty.turn_offset);
+    reader.ReadInto(turn_penalty.location.lat);
+    reader.ReadInto(turn_penalty.location.lon);
+    auto const num_conditions = reader.ReadElementCount64();
+    turn_penalty.conditions.resize(num_conditions);
+    for (auto &condition : turn_penalty.conditions)
+    {
+        reader.ReadInto(condition.modifier);
+        storage::serialization::read(reader, condition.times);
+        storage::serialization::read(reader, condition.weekdays);
+        storage::serialization::read(reader, condition.monthdays);
+    }
+}
+
+inline void write(storage::io::FileWriter &writer, const ConditionalTurnPenalty &turn_penalty)
+{
+    writer.WriteOne(turn_penalty.turn_offset);
+    writer.WriteOne(static_cast<util::FixedLatitude::value_type>(turn_penalty.location.lat));
+    writer.WriteOne(static_cast<util::FixedLongitude::value_type>(turn_penalty.location.lon));
+    writer.WriteElementCount64(turn_penalty.conditions.size());
+    for (const auto &c : turn_penalty.conditions)
+    {
+        writer.WriteOne(c.modifier);
+        storage::serialization::write(writer, c.times);
+        storage::serialization::write(writer, c.weekdays);
+        storage::serialization::write(writer, c.monthdays);
+    }
+}
+
+inline void write(storage::io::FileWriter &writer,
+                  const std::vector<ConditionalTurnPenalty> &conditional_penalties)
+{
+    writer.WriteElementCount64(conditional_penalties.size());
+    for (const auto &penalty : conditional_penalties)
+        write(writer, penalty);
+}
+
+inline void read(storage::io::FileReader &reader,
+                 std::vector<ConditionalTurnPenalty> &conditional_penalties)
+{
+    auto const num_elements = reader.ReadElementCount64();
+    conditional_penalties.resize(num_elements);
+    for (auto &penalty : conditional_penalties)
+        read(reader, penalty);
+}
 }
 }
 }

include/extractor/way_restriction_map.hpp

@@ -8,6 +8,7 @@
 #include <boost/unordered_map.hpp>
 
 #include "extractor/restriction.hpp"
+#include "extractor/restriction_index.hpp"
 #include "util/integer_range.hpp"
 #include "util/typedefs.hpp"
 
@@ -18,6 +19,8 @@ namespace osrm
 namespace extractor
 {
 
+// The WayRestrictionMap uses ConditionalTurnRestrictions in general. Most restrictions will have
+// empty conditions, though.
 class WayRestrictionMap
 {
   public:
@@ -26,7 +29,7 @@ class WayRestrictionMap
         NodeID from;
         NodeID to;
     };
-    WayRestrictionMap(const std::vector<TurnRestriction> &turn_restrictions);
+    WayRestrictionMap(const std::vector<ConditionalTurnRestriction> &conditional_restrictions);
 
     // Check if an edge between two nodes is a restricted turn. The check needs to be performed to
     // find duplicated nodes during the creation of edge-based-edges
@@ -43,10 +46,13 @@ class WayRestrictionMap
     std::vector<ViaWay> DuplicatedNodeRepresentatives() const;
 
     // Access all duplicated NodeIDs for a set of nodes indicating a via way
-    util::range<DuplicatedNodeID> DuplicatedNodeIDs(const NodeID from, const NodeID to) const;
+    std::vector<DuplicatedNodeID> DuplicatedNodeIDs(const NodeID from, const NodeID to) const;
 
     // check whether a turn onto a given node is restricted, when coming from a duplicated node
     bool IsRestricted(DuplicatedNodeID duplicated_node, const NodeID to) const;
+    // Get the restriction resulting in ^ IsRestricted. Requires IsRestricted to evaluate to true
+    const ConditionalTurnRestriction &GetRestriction(DuplicatedNodeID duplicated_node,
+                                                     const NodeID to) const;
 
     // changes edge_based_node to the correct duplicated_node_id in case node_based_from,
     // node_based_via, node_based_to can be identified with a restriction group
@@ -76,11 +82,8 @@ class WayRestrictionMap
     //                    EBN: 0 . | 2 | 3 | 4 ...
     // duplicated node groups: ... | 5 | 7 | ...
     std::vector<DuplicatedNodeID> duplicated_node_groups;
-
-    boost::unordered_multimap<std::pair<NodeID, NodeID>, RestrictionID> restriction_starts;
-    boost::unordered_multimap<std::pair<NodeID, NodeID>, RestrictionID> restriction_ends;
-
-    std::vector<TurnRestriction> restriction_data;
+    std::vector<ConditionalTurnRestriction> restriction_data;
+    RestrictionIndex<ConditionalTurnRestriction> restriction_starts;
 };
 
 } // namespace extractor

include/storage/serialization.hpp

@@ -97,7 +97,7 @@ template <typename T> void write(io::FileWriter &writer, const std::vector<T> &d
 {
     const auto count = data.size();
     writer.WriteElementCount64(count);
-    return writer.WriteFrom(data.data(), count);
+    writer.WriteFrom(data.data(), count);
 }
 
 template <typename T> void read(io::FileReader &reader, util::vector_view<T> &data)

include/util/geojson_debug_policies.hpp

@@ -18,13 +18,13 @@ namespace util
 
 struct NodeIdVectorToLineString
 {
-    NodeIdVectorToLineString(const std::vector<extractor::QueryNode> &node_coordinates);
+    NodeIdVectorToLineString(const std::vector<util::Coordinate> &node_coordinates);
 
     // converts a vector of node ids into a linestring geojson feature
     util::json::Object operator()(const std::vector<NodeID> &node_ids,
                                   const boost::optional<json::Object> &properties = {}) const;
 
-    const std::vector<extractor::QueryNode> &node_coordinates;
+    const std::vector<util::Coordinate> &node_coordinates;
 };
 
 struct CoordinateVectorToLineString
@@ -36,13 +36,13 @@ struct CoordinateVectorToLineString
 
 struct NodeIdVectorToMultiPoint
 {
-    NodeIdVectorToMultiPoint(const std::vector<extractor::QueryNode> &node_coordinates);
+    NodeIdVectorToMultiPoint(const std::vector<util::Coordinate> &node_coordinates);
 
     // converts a vector of node ids into a linestring geojson feature
     util::json::Object operator()(const std::vector<NodeID> &node_ids,
                                   const boost::optional<json::Object> &properties = {}) const;
 
-    const std::vector<extractor::QueryNode> &node_coordinates;
+    const std::vector<util::Coordinate> &node_coordinates;
 };
 
 struct CoordinateVectorToMultiPoint

include/util/geojson_debug_policy_toolkit.hpp

@@ -69,12 +69,12 @@ struct CoordinateToJsonArray
 
 struct NodeIdToCoordinate
 {
-    NodeIdToCoordinate(const std::vector<extractor::QueryNode> &node_coordinates)
+    NodeIdToCoordinate(const std::vector<util::Coordinate> &node_coordinates)
         : node_coordinates(node_coordinates)
     {
     }
 
-    const std::vector<extractor::QueryNode> &node_coordinates;
+    const std::vector<util::Coordinate> &node_coordinates;
 
     util::json::Array operator()(const NodeID nid)
     {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "osrm",
-  "version": "5.10.0-rc.1",
+  "version": "5.12.0-roundaboutexits.1",
   "private": false,
   "description": "The Open Source Routing Machine is a high performance routing engine written in C++14 designed to run on OpenStreetMap data.",
   "dependencies": {
@@ -15,7 +15,7 @@
     ]
   },
   "scripts": {
-    "lint": "eslint -c ./.eslintrc features/step_definitions/ features/support/",
+    "lint": "node ./node_modules/eslint/bin/eslint.js -c ./.eslintrc features/step_definitions/ features/support/",
     "test": "npm run lint && node ./node_modules/cucumber/bin/cucumber.js features/ -p verify && node ./node_modules/cucumber/bin/cucumber.js features/ -p mld",
     "clean": "rm -rf test/cache",
     "docs": "./scripts/build_api_docs.sh",
@@ -37,6 +37,7 @@
   },
   "devDependencies": {
     "aws-sdk": "~2.0.31",
+    "babel-plugin-transform-class-properties": "^6.24.1",
     "chalk": "^1.1.3",
     "cucumber": "^1.2.1",
     "d3-queue": "^2.0.3",

profiles/car.lua

@@ -46,7 +46,6 @@ function setup()
     barrier_whitelist = Set {
       'cattle_grid',
       'border_control',
-      'checkpoint',
       'toll_booth',
       'sally_port',
       'gate',

src/engine/api/json_factory.cpp

@@ -44,12 +44,13 @@ const constexpr char *modifier_names[] = {"uturn",
 // translations of TurnTypes. Not all types are exposed to the outside world.
 // invalid types should never be returned as part of the API
 const constexpr char *turn_type_names[] = {
-    "invalid",         "new name",   "continue", "turn",        "merge",
-    "on ramp",         "off ramp",   "fork",     "end of road", "notification",
-    "roundabout",      "roundabout", "rotary",   "rotary",      "roundabout turn",
-    "roundabout turn", "use lane",   "invalid",  "invalid",     "invalid",
-    "invalid",         "invalid",    "invalid",  "invalid",     "invalid",
-    "invalid",         "invalid"};
+    "invalid",         "new name",     "continue",        "turn",
+    "merge",           "on ramp",      "off ramp",        "fork",
+    "end of road",     "notification", "roundabout",      "exit roundabout",
+    "rotary",          "exit rotary",  "roundabout turn", "roundabout turn",
+    "use lane",        "invalid",      "invalid",         "roundabout",
+    "exit roundabout", "rotary",       "exit rotary",     "roundabout turn",
+    "exit roundabout", "invalid",      "invalid"};
 
 const constexpr char *waypoint_type_names[] = {"invalid", "arrive", "depart"};
 
@@ -68,7 +69,7 @@ inline bool hasValidLanes(const guidance::IntermediateIntersection &intersection
 std::string instructionTypeToString(const TurnType::Enum type)
 {
     static_assert(sizeof(turn_type_names) / sizeof(turn_type_names[0]) >= TurnType::MaxTurnType,
-                  "Some turn types has not string representation.");
+                  "Some turn types doesn't have a string representation.");
     return turn_type_names[static_cast<std::size_t>(type)];
 }
 

src/engine/guidance/collapse_scenario_detection.cpp

@@ -17,7 +17,7 @@ namespace
 {
 
 // check bearings for u-turns.
-// since bearings are wrapped around at 0 (we only support 0,360), we need to do some minor math to
+// since bearings are wrapped around at 0 (we only support 0,360), we need to do some minor math to
 // check if bearings `a` and `b` go in opposite directions. In general we accept some minor
 // deviations for u-turns.
 bool bearingsAreReversed(const double bearing_in, const double bearing_out)
@@ -123,7 +123,7 @@ bool isStaggeredIntersection(const RouteStepIterator step_prior_to_intersection,
 
     const auto angle = [](const RouteStep &step) {
         const auto &intersection = step.intersections.front();
-        const auto entry_bearing = intersection.bearings[intersection.in];
+        const auto entry_bearing = util::bearing::reverse(intersection.bearings[intersection.in]);
         const auto exit_bearing = intersection.bearings[intersection.out];
         return util::bearing::angleBetween(entry_bearing, exit_bearing);
     };

src/engine/guidance/collapse_turns.cpp

@@ -158,6 +158,18 @@ void TransferTurnTypeStrategy::operator()(RouteStep &step_at_turn_location,
 void AdjustToCombinedTurnAngleStrategy::operator()(RouteStep &step_at_turn_location,
                                                    const RouteStep &transfer_from_step) const
 {
+    // Forks point to left/right. By doing a combined angle, we would risk ending up with
+    // unreasonable fork instrucitons. The direction of a fork only depends on the forking location,
+    // not further angles coming up
+    //
+    //          d
+    //       .  c
+    // a - b
+    //
+    // could end up as `fork left` for `a-b-c`, instead of fork-right
+    if (hasTurnType(step_at_turn_location, TurnType::Fork))
+        return;
+
     // TODO assert transfer_from_step == step_at_turn_location + 1
     const auto angle = findTotalTurnAngle(step_at_turn_location, transfer_from_step);
     step_at_turn_location.maneuver.instruction.direction_modifier = getTurnDirection(angle);
@@ -173,7 +185,19 @@ void AdjustToCombinedTurnStrategy::operator()(RouteStep &step_at_turn_location,
                                               const RouteStep &transfer_from_step) const
 {
     const auto angle = findTotalTurnAngle(step_at_turn_location, transfer_from_step);
-    const auto new_modifier = getTurnDirection(angle);
+
+    // Forks point to left/right. By doing a combined angle, we would risk ending up with
+    // unreasonable fork instrucitons. The direction of a fork only depends on the forking location,
+    // not further angles coming up
+    //
+    //          d
+    //       .  c
+    // a - b
+    //
+    // could end up as `fork left` for `a-b-c`, instead of fork-right
+    const auto new_modifier = hasTurnType(step_at_turn_location, TurnType::Fork)
+                                  ? step_at_turn_location.maneuver.instruction.direction_modifier
+                                  : getTurnDirection(angle);
 
     // a turn that is a new name or straight (turn/continue)
     const auto is_non_turn = [](const RouteStep &step) {

src/engine/guidance/post_processing.cpp

@@ -7,6 +7,7 @@
 
 #include "engine/guidance/collapsing_utility.hpp"
 #include "util/bearing.hpp"
+#include "util/group_by.hpp"
 #include "util/guidance/name_announcements.hpp"
 #include "util/guidance/turn_lanes.hpp"
 
@@ -14,6 +15,8 @@
 #include <boost/numeric/conversion/cast.hpp>
 #include <boost/range/iterator_range.hpp>
 
+#include "engine/guidance/collapsing_utility.hpp"
+
 #include <algorithm>
 #include <cmath>
 #include <cstddef>
@@ -26,6 +29,8 @@ using osrm::extractor::guidance::hasRampType;
 using osrm::extractor::guidance::mirrorDirectionModifier;
 using osrm::extractor::guidance::bearingToDirectionModifier;
 
+using RouteStepIterator = std::vector<osrm::engine::guidance::RouteStep>::iterator;
+
 namespace osrm
 {
 namespace engine
@@ -36,208 +41,137 @@ namespace guidance
 namespace
 {
 
-void fixFinalRoundabout(std::vector<RouteStep> &steps)
+// Ensure that after we are done with the roundabout, only the roundabout instructions themselves
+// remain
+void compressRange(const RouteStepIterator begin, const RouteStepIterator end)
 {
-    for (std::size_t propagation_index = steps.size() - 1; propagation_index > 0;
-         --propagation_index)
-    {
-        auto &propagation_step = steps[propagation_index];
-        propagation_step.maneuver.exit = 0;
-        if (entersRoundabout(propagation_step.maneuver.instruction))
-        {
-            // remember the current name as rotary name in tha case we end in a rotary
-            if (propagation_step.maneuver.instruction.type == TurnType::EnterRotary ||
-                propagation_step.maneuver.instruction.type == TurnType::EnterRotaryAtExit)
-            {
-                propagation_step.rotary_name = propagation_step.name;
-                propagation_step.rotary_pronunciation = propagation_step.pronunciation;
-            }
-            else if (propagation_step.maneuver.instruction.type ==
-                         TurnType::EnterRoundaboutIntersection ||
-                     propagation_step.maneuver.instruction.type ==
-                         TurnType::EnterRoundaboutIntersectionAtExit)
-            {
-                propagation_step.maneuver.instruction.type = TurnType::EnterRoundabout;
-            }
+    if (begin == end)
+        return;
 
-            return;
-        }
-        // accumulate turn data into the enter instructions
-        else if (propagation_step.maneuver.instruction.type == TurnType::StayOnRoundabout)
+    for (auto itr = begin + 1; itr != end; ++itr)
+    {
+        // ensure not to invalidate the final arrive
+        if (!hasWaypointType(*itr))
         {
-            // TODO this operates on the data that is in the instructions.
-            // We are missing out on the final segment after the last stay-on-roundabout
-            // instruction though. it is not contained somewhere until now
-            steps[propagation_index - 1].ElongateBy(propagation_step);
-            steps[propagation_index - 1].maneuver.exit = propagation_step.maneuver.exit;
-            propagation_step.Invalidate();
+            begin->ElongateBy(*itr);
+            itr->Invalidate();
         }
     }
 }
 
-bool setUpRoundabout(RouteStep &step)
+// this function handles a single roundabout between enter (which might be missing) to exit (which
+// might be missing as well)
+void processRoundaboutExits(const RouteStepIterator begin, const RouteStepIterator end)
 {
-    // basic entry into a roundabout
-    // Special case handling, if an entry is directly tied to an exit
-    const auto instruction = step.maneuver.instruction;
-    if (instruction.type == TurnType::EnterRotaryAtExit ||
-        instruction.type == TurnType::EnterRoundaboutAtExit ||
-        instruction.type == TurnType::EnterRoundaboutIntersectionAtExit)
+    auto const last = end - 1;
+    // If we do not exit the roundabout, there is no exit to report. All good here
+    if (!leavesRoundabout(last->maneuver.instruction))
     {
-        // Here we consider an actual entry, not an exit. We simply have to count the additional
-        // exit
-        step.maneuver.exit = 1;
-        // prevent futher special case handling of these two.
-        if (instruction.type == TurnType::EnterRotaryAtExit)
-            step.maneuver.instruction.type = TurnType::EnterRotary;
-        else if (instruction.type == TurnType::EnterRoundaboutAtExit)
-            step.maneuver.instruction.type = TurnType::EnterRoundabout;
-        else
-            step.maneuver.instruction.type = TurnType::EnterRoundaboutIntersection;
+        // first we do some clean-up
+        if (begin->maneuver.instruction.type == TurnType::EnterRotary ||
+            begin->maneuver.instruction.type == TurnType::EnterRotaryAtExit)
+        {
+            begin->rotary_name = begin->name;
+            begin->rotary_pronunciation = begin->pronunciation;
+        }
+        // roundabout turns don't make sense without an exit, update the type
+        else if (entersRoundabout(begin->maneuver.instruction) &&
+                 (begin->maneuver.instruction.type == TurnType::EnterRoundaboutIntersection ||
+                  begin->maneuver.instruction.type == TurnType::EnterRoundaboutIntersectionAtExit))
+        {
+            begin->maneuver.instruction.type = TurnType::EnterRoundabout;
+        }
+
+        // We are doing a roundtrip on the roundabout, Nothing to do here but to remove the
+        // instructions
+        compressRange(begin, end);
+        return;
     }
 
-    if (leavesRoundabout(instruction))
-    {
-        // This set-up, even though it looks the same, is actually looking at entering AND exiting
-        step.maneuver.exit = 1; // count the otherwise missing exit
+    const auto passes_exit_or_leaves_roundabout = [](auto const &step) {
+        return staysOnRoundabout(step.maneuver.instruction) ||
+               leavesRoundabout(step.maneuver.instruction);
+    };
 
-        // prevent futher special case handling of these two.
-        if (instruction.type == TurnType::EnterAndExitRotary)
-            step.maneuver.instruction.type = TurnType::EnterRotary;
-        else if (instruction.type == TurnType::EnterAndExitRoundabout)
-            step.maneuver.instruction.type = TurnType::EnterRoundabout;
-        else
-            step.maneuver.instruction.type = TurnType::EnterRoundaboutIntersection;
-        return false;
+    // exit count
+    const auto exit = std::count_if(begin, end, passes_exit_or_leaves_roundabout);
+
+    // removes all intermediate instructions, assigns names and exit numbers
+    BOOST_ASSERT(leavesRoundabout(last->maneuver.instruction));
+    BOOST_ASSERT(std::distance(begin, end) >= 1);
+    last->maneuver.exit = exit;
+
+    // when we actually have an enter instruction, we can store all the information on it that we
+    // need, otherwise we only provide the exit instruciton. In case of re-routing on the
+    // roundabout, this might result in strange behaviour, but this way we are more resiliant and we
+    // do provide exit after all
+    if (entersRoundabout(begin->maneuver.instruction))
+    {
+        begin->maneuver.exit = exit;
+        // special handling for rotaries: remember the name (legacy feature, due to
+        // adapt-step-signage)
+        if (begin->maneuver.instruction.type == TurnType::EnterRotary ||
+            begin->maneuver.instruction.type == TurnType::EnterRotaryAtExit)
+        {
+            begin->rotary_name = begin->name;
+            begin->rotary_pronunciation = begin->pronunciation;
+        }
+        // compute the total direction modifier for roundabout turns
+        else if (begin->maneuver.instruction.type == TurnType::EnterRoundaboutIntersection ||
+                 begin->maneuver.instruction.type == TurnType::EnterRoundaboutIntersectionAtExit)
+        {
+            const auto entry_intersection = begin->intersections.front();
+
+            const auto exit_intersection = last->intersections.front();
+            const auto exit_bearing = exit_intersection.bearings[exit_intersection.out];
+
+            BOOST_ASSERT(!begin->intersections.empty());
+            const double angle = util::bearing::angleBetween(
+                util::bearing::reverse(entry_intersection.bearings[entry_intersection.in]),
+                exit_bearing);
+
+            begin->maneuver.instruction.direction_modifier = getTurnDirection(angle);
+        }
+        begin->AdaptStepSignage(*last);
+    }
+
+    // in case of a roundabout turn, we do not emit an exit as long as the mode remains the same
+    if ((begin->maneuver.instruction.type == TurnType::EnterRoundaboutIntersection ||
+         begin->maneuver.instruction.type == TurnType::EnterRoundaboutIntersectionAtExit) &&
+        begin->mode == last->mode)
+    {
+        compressRange(begin, end);
     }
     else
     {
-        return true;
+        // do not remove last (the exit instruction)
+        compressRange(begin, last);
     }
 }
 
-void closeOffRoundabout(const bool on_roundabout,
-                        std::vector<RouteStep> &steps,
-                        std::size_t step_index)
+// roundabout groups are a sequence of roundabout instructions. This can contain enter/exit
+// instructions in between
+void processRoundaboutGroups(const std::pair<RouteStepIterator, RouteStepIterator> &range)
 {
-    auto &step = steps[step_index];
-    step.maneuver.exit += 1;
-    if (!on_roundabout)
+    const auto leaves_roundabout = [](auto const &step) {
+        return leavesRoundabout(step.maneuver.instruction);
+    };
+
+    auto itr = range.first;
+    while (itr != range.second)
     {
-        BOOST_ASSERT(steps.size() >= 2);
-
-        // We reached a special case that requires the addition of a special route step in the
-        // beginning. We started in a roundabout, so to announce the exit, we move use the exit
-        // instruction and move it right to the beginning to make sure to immediately announce the
-        // exit.
-        BOOST_ASSERT(leavesRoundabout(steps[1].maneuver.instruction) ||
-                     steps[1].maneuver.instruction.type == TurnType::StayOnRoundabout ||
-                     steps[1].maneuver.instruction.type == TurnType::Suppressed ||
-                     steps[1].maneuver.instruction.type == TurnType::NoTurn);
-        steps[0].geometry_end = 1;
-        steps[1].geometry_begin = 0;
-        steps[1].AddInFront(steps[0]);
-        steps[1].intersections.erase(steps[1].intersections.begin()); // otherwise we copy the
-                                                                      // source
-        if (leavesRoundabout(steps[1].maneuver.instruction))
-            steps[1].maneuver.exit = 1;
-        steps[0].duration = 0;
-        steps[0].distance = 0;
-        const auto exitToEnter = [](const TurnType::Enum type) {
-            if (TurnType::ExitRotary == type)
-                return TurnType::EnterRotary;
-            // if we do not enter the roundabout Intersection, we cannot treat the full traversal as
-            // a turn. So we switch it up to the roundabout type
-            else if (type == TurnType::ExitRoundaboutIntersection)
-                return TurnType::EnterRoundabout;
-            else
-                return TurnType::EnterRoundabout;
-        };
-        steps[1].maneuver.instruction.type = exitToEnter(step.maneuver.instruction.type);
-        if (steps[1].maneuver.instruction.type == TurnType::EnterRotary)
+        auto exit = std::find_if(itr, range.second, leaves_roundabout);
+        if (exit == range.second)
         {
-            steps[1].rotary_name = steps[0].name;
-            steps[1].rotary_pronunciation = steps[0].pronunciation;
+            processRoundaboutExits(itr, exit);
+            itr = exit;
         }
-    }
-
-    if (step_index > 1)
-    {
-        auto &exit_step = steps[step_index];
-        auto &prev_step = steps[step_index - 1];
-        // In case the step with the roundabout exit instruction cannot be merged with the
-        // previous step we change the instruction to a normal turn
-        if (!guidance::haveSameMode(exit_step, prev_step))
+        else
         {
-            BOOST_ASSERT(leavesRoundabout(exit_step.maneuver.instruction));
-            if (!entersRoundabout(prev_step.maneuver.instruction))
-            {
-                prev_step.maneuver.instruction = exit_step.maneuver.instruction;
-            }
-            prev_step.maneuver.exit = exit_step.maneuver.exit;
-            exit_step.maneuver.instruction.type = TurnType::Notification;
-            step_index--;
+            processRoundaboutExits(itr, exit + 1);
+            itr = exit + 1;
         }
     }
-
-    // Normal exit from the roundabout, or exit from a previously fixed roundabout. Propagate the
-    // index back to the entering location and prepare the current silent set of instructions for
-    // removal.
-    std::vector<std::size_t> intermediate_steps;
-    BOOST_ASSERT(!steps[step_index].intersections.empty());
-    // the very first intersection in the steps represents the location of the turn. Following
-    // intersections are locations passed along the way
-    const auto exit_intersection = steps[step_index].intersections.front();
-    const auto exit_bearing = exit_intersection.bearings[exit_intersection.out];
-    const auto destination_copy = step;
-
-    if (step_index > 1)
-    {
-        // The very first route-step is head, so we cannot iterate past that one
-        for (std::size_t propagation_index = step_index - 1; propagation_index > 0;
-             --propagation_index)
-        {
-            auto &propagation_step = steps[propagation_index];
-            auto &next_step = steps[propagation_index + 1];
-            if (guidance::haveSameMode(propagation_step, next_step))
-            {
-                propagation_step.ElongateBy(next_step);
-                propagation_step.maneuver.exit = next_step.maneuver.exit;
-                next_step.Invalidate();
-            }
-
-            if (entersRoundabout(propagation_step.maneuver.instruction))
-            {
-                const auto entry_intersection = propagation_step.intersections.front();
-
-                // remember rotary name
-                if (propagation_step.maneuver.instruction.type == TurnType::EnterRotary ||
-                    propagation_step.maneuver.instruction.type == TurnType::EnterRotaryAtExit)
-                {
-                    propagation_step.rotary_name = propagation_step.name;
-                    propagation_step.rotary_pronunciation = propagation_step.pronunciation;
-                }
-                else if (propagation_step.maneuver.instruction.type ==
-                             TurnType::EnterRoundaboutIntersection ||
-                         propagation_step.maneuver.instruction.type ==
-                             TurnType::EnterRoundaboutIntersectionAtExit)
-                {
-                    BOOST_ASSERT(!propagation_step.intersections.empty());
-                    const double angle = util::bearing::angleBetween(
-                        util::bearing::reverse(entry_intersection.bearings[entry_intersection.in]),
-                        exit_bearing);
-
-                    auto bearings = propagation_step.intersections.front().bearings;
-                    propagation_step.maneuver.instruction.direction_modifier =
-                        getTurnDirection(angle);
-                }
-
-                propagation_step.AdaptStepSignage(destination_copy);
-                break;
-            }
-        }
-        // remove exit
-    }
 }
 
 } // namespace
@@ -248,64 +182,49 @@ void closeOffRoundabout(const bool on_roundabout,
 // They are required for maintenance purposes. We can calculate the number
 // of exits to pass in a roundabout and the number of intersections
 // that we come across.
-std::vector<RouteStep> postProcess(std::vector<RouteStep> steps)
+std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps)
 {
-    // the steps should always include the first/last step in form of a location
-    BOOST_ASSERT(steps.size() >= 2);
-    if (steps.size() == 2)
+    // check if a step has roundabout type
+    const auto has_roundabout_type = [](auto const &step) {
+        return hasRoundaboutType(step.maneuver.instruction);
+    };
+    const auto first_roundabout_type =
+        std::find_if(steps.begin(), steps.end(), has_roundabout_type);
+
+    // no roundabout to process?
+    if (first_roundabout_type == steps.end())
         return steps;
 
-    // Count Street Exits forward
-    bool on_roundabout = false;
-    bool has_entered_roundabout = false;
+    // unless the first instruction enters the roundabout, we are currently on a roundabout. This is
+    // a special case that happens if the route starts on a roundabout. It is a border case, but
+    // could happen during re-routing. In the case of re-routing, exit counting might be confusing,
+    // but it is the best we can do
+    bool currently_on_roundabout = !entersRoundabout(first_roundabout_type->maneuver.instruction);
 
-    // count the exits forward. if enter/exit roundabout happen both, no further treatment is
-    // required. We might end up with only one of them (e.g. starting within a roundabout)
-    // or having a via-point in the roundabout.
-    // In this case, exits are numbered from the start of the leg.
-    for (std::size_t step_index = 0; step_index < steps.size(); ++step_index)
-    {
-        const auto next_step_index = step_index + 1;
-        auto &step = steps[step_index];
-        const auto instruction = step.maneuver.instruction;
-        if (entersRoundabout(instruction))
+    // this group by paradigm does might contain intermediate roundabout instructions, when they are
+    // directly connected. Otherwise it will be a sequence containing everything from enter to exit.
+    // If we already start on the roundabout, the first valid place will be steps.begin().
+    const auto is_on_roundabout = [&currently_on_roundabout](const auto &step) {
+        if (currently_on_roundabout)
         {
-            has_entered_roundabout = setUpRoundabout(step);
+            if (leavesRoundabout(step.maneuver.instruction))
+                currently_on_roundabout = false;
 
-            if (has_entered_roundabout && next_step_index < steps.size())
-                steps[next_step_index].maneuver.exit = step.maneuver.exit;
+            return true;
         }
-        else if (instruction.type == TurnType::StayOnRoundabout)
+        else
         {
-            on_roundabout = true;
-            // increase the exit number we require passing the exit
-            step.maneuver.exit += 1;
-            if (next_step_index < steps.size())
-                steps[next_step_index].maneuver.exit = step.maneuver.exit;
+            currently_on_roundabout = entersRoundabout(step.maneuver.instruction);
+            auto result = currently_on_roundabout;
+            // cases that immediately exit the roundabout
+            if (currently_on_roundabout)
+                currently_on_roundabout = !leavesRoundabout(step.maneuver.instruction);
+            return result;
         }
-        else if (leavesRoundabout(instruction))
-        {
-            // if (!has_entered_roundabout)
-            // in case the we are not on a roundabout, the very first instruction
-            // after the depart will be transformed into a roundabout and become
-            // the first valid instruction
-            closeOffRoundabout(has_entered_roundabout, steps, step_index);
-            has_entered_roundabout = false;
-            on_roundabout = false;
-        }
-        else if (on_roundabout && next_step_index < steps.size())
-        {
-            steps[next_step_index].maneuver.exit = step.maneuver.exit;
-        }
-    }
+    };
 
-    // unterminated roundabout
-    // Move backwards through the instructions until the start and remove the exit number
-    // A roundabout without exit translates to enter-roundabout
-    if (has_entered_roundabout || on_roundabout)
-    {
-        fixFinalRoundabout(steps);
-    }
+    // for each range of instructions between begin/end of a roundabout assign
+    util::group_by(steps.begin(), steps.end(), is_on_roundabout, processRoundaboutGroups);
 
     BOOST_ASSERT(steps.front().intersections.size() >= 1);
     BOOST_ASSERT(steps.front().intersections.front().bearings.size() == 1);
@@ -333,8 +252,7 @@ void trimShortSegments(std::vector<RouteStep> &steps, LegGeometry &geometry)
         return;
 
     // if phantom node is located at the connection of two segments, either one can be selected
-    // as
-    // turn
+    // as turn
     //
     // a --- b
     //       |
@@ -629,7 +547,21 @@ std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps)
                 BOOST_ASSERT(step_index > 0);
                 const auto &previous_step = steps[last_valid_instruction];
                 if (previous_step.intersections.size() < MIN_END_OF_ROAD_INTERSECTIONS)
-                    step.maneuver.instruction.type = TurnType::Turn;
+                {
+                    bool same_name =
+                        !(step.name.empty() && step.ref.empty()) &&
+                        !util::guidance::requiresNameAnnounced(previous_step.name,
+                                                               previous_step.ref,
+                                                               previous_step.pronunciation,
+                                                               previous_step.exits,
+                                                               step.name,
+                                                               step.ref,
+                                                               step.pronunciation,
+                                                               step.exits);
+
+                    step.maneuver.instruction.type =
+                        same_name ? TurnType::Continue : TurnType::Turn;
+                }
             }
 
             // Remember the last non silent instruction

src/engine/routing_algorithms/shortest_path.cpp

@@ -1,10 +1,6 @@
-#include "engine/routing_algorithms/shortest_path.hpp"
 #include "engine/routing_algorithms/routing_base_ch.hpp"
 #include "engine/routing_algorithms/routing_base_mld.hpp"
-
-#include <boost/assert.hpp>
-#include <boost/optional.hpp>
-#include <memory>
+#include "engine/routing_algorithms/shortest_path_impl.hpp"
 
 namespace osrm
 {
@@ -13,449 +9,6 @@ namespace engine
 namespace routing_algorithms
 {
 
-namespace
-{
-
-const static constexpr bool DO_NOT_FORCE_LOOP = false;
-
-// allows a uturn at the target_phantom
-// searches source forward/reverse -> target forward/reverse
-template <typename Algorithm>
-void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
-                     const DataFacade<Algorithm> &facade,
-                     typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                     typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                     const bool search_from_forward_node,
-                     const bool search_from_reverse_node,
-                     const bool search_to_forward_node,
-                     const bool search_to_reverse_node,
-                     const PhantomNode &source_phantom,
-                     const PhantomNode &target_phantom,
-                     const int total_weight_to_forward,
-                     const int total_weight_to_reverse,
-                     int &new_total_weight,
-                     std::vector<NodeID> &leg_packed_path)
-{
-    forward_heap.Clear();
-    reverse_heap.Clear();
-    if (search_from_forward_node)
-    {
-        forward_heap.Insert(source_phantom.forward_segment_id.id,
-                            -source_phantom.GetForwardWeightPlusOffset(),
-                            source_phantom.forward_segment_id.id);
-    }
-    if (search_from_reverse_node)
-    {
-        forward_heap.Insert(source_phantom.reverse_segment_id.id,
-                            -source_phantom.GetReverseWeightPlusOffset(),
-                            source_phantom.reverse_segment_id.id);
-    }
-    if (search_to_forward_node)
-    {
-        reverse_heap.Insert(target_phantom.forward_segment_id.id,
-                            target_phantom.GetForwardWeightPlusOffset(),
-                            target_phantom.forward_segment_id.id);
-    }
-    if (search_to_reverse_node)
-    {
-        reverse_heap.Insert(target_phantom.reverse_segment_id.id,
-                            target_phantom.GetReverseWeightPlusOffset(),
-                            target_phantom.reverse_segment_id.id);
-    }
-
-    // this is only relevent if source and target are on the same compressed edge
-    auto is_oneway_source = !(search_from_forward_node && search_from_reverse_node);
-    auto is_oneway_target = !(search_to_forward_node && search_to_reverse_node);
-    // we only enable loops here if we can't search from forward to backward node
-    auto needs_loop_forwards = is_oneway_source && needsLoopForward(source_phantom, target_phantom);
-    auto needs_loop_backwards =
-        is_oneway_target && needsLoopBackwards(source_phantom, target_phantom);
-
-    search(engine_working_data,
-           facade,
-           forward_heap,
-           reverse_heap,
-           new_total_weight,
-           leg_packed_path,
-           needs_loop_forwards,
-           needs_loop_backwards,
-           {source_phantom, target_phantom});
-
-    // if no route is found between two parts of the via-route, the entire route becomes
-    // invalid. Adding to invalid edge weight sadly doesn't return an invalid edge weight. Here
-    // we prevent the possible overflow, faking the addition of infinity + x == infinity
-    if (new_total_weight != INVALID_EDGE_WEIGHT)
-        new_total_weight += std::min(total_weight_to_forward, total_weight_to_reverse);
-}
-
-// searches shortest path between:
-// source forward/reverse -> target forward
-// source forward/reverse -> target reverse
-template <typename Algorithm>
-void search(SearchEngineData<Algorithm> &engine_working_data,
-            const DataFacade<Algorithm> &facade,
-            typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-            typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-            const bool search_from_forward_node,
-            const bool search_from_reverse_node,
-            const bool search_to_forward_node,
-            const bool search_to_reverse_node,
-            const PhantomNode &source_phantom,
-            const PhantomNode &target_phantom,
-            const int total_weight_to_forward,
-            const int total_weight_to_reverse,
-            int &new_total_weight_to_forward,
-            int &new_total_weight_to_reverse,
-            std::vector<NodeID> &leg_packed_path_forward,
-            std::vector<NodeID> &leg_packed_path_reverse)
-{
-    if (search_to_forward_node)
-    {
-        forward_heap.Clear();
-        reverse_heap.Clear();
-        reverse_heap.Insert(target_phantom.forward_segment_id.id,
-                            target_phantom.GetForwardWeightPlusOffset(),
-                            target_phantom.forward_segment_id.id);
-
-        if (search_from_forward_node)
-        {
-            forward_heap.Insert(source_phantom.forward_segment_id.id,
-                                total_weight_to_forward -
-                                    source_phantom.GetForwardWeightPlusOffset(),
-                                source_phantom.forward_segment_id.id);
-        }
-        if (search_from_reverse_node)
-        {
-            forward_heap.Insert(source_phantom.reverse_segment_id.id,
-                                total_weight_to_reverse -
-                                    source_phantom.GetReverseWeightPlusOffset(),
-                                source_phantom.reverse_segment_id.id);
-        }
-
-        search(engine_working_data,
-               facade,
-               forward_heap,
-               reverse_heap,
-               new_total_weight_to_forward,
-               leg_packed_path_forward,
-               needsLoopForward(source_phantom, target_phantom),
-               routing_algorithms::DO_NOT_FORCE_LOOP,
-               {source_phantom, target_phantom});
-    }
-
-    if (search_to_reverse_node)
-    {
-        forward_heap.Clear();
-        reverse_heap.Clear();
-        reverse_heap.Insert(target_phantom.reverse_segment_id.id,
-                            target_phantom.GetReverseWeightPlusOffset(),
-                            target_phantom.reverse_segment_id.id);
-        if (search_from_forward_node)
-        {
-            forward_heap.Insert(source_phantom.forward_segment_id.id,
-                                total_weight_to_forward -
-                                    source_phantom.GetForwardWeightPlusOffset(),
-                                source_phantom.forward_segment_id.id);
-        }
-        if (search_from_reverse_node)
-        {
-            forward_heap.Insert(source_phantom.reverse_segment_id.id,
-                                total_weight_to_reverse -
-                                    source_phantom.GetReverseWeightPlusOffset(),
-                                source_phantom.reverse_segment_id.id);
-        }
-
-        search(engine_working_data,
-               facade,
-               forward_heap,
-               reverse_heap,
-               new_total_weight_to_reverse,
-               leg_packed_path_reverse,
-               routing_algorithms::DO_NOT_FORCE_LOOP,
-               needsLoopBackwards(source_phantom, target_phantom),
-               {source_phantom, target_phantom});
-    }
-}
-
-template <typename Algorithm>
-void unpackLegs(const DataFacade<Algorithm> &facade,
-                const std::vector<PhantomNodes> &phantom_nodes_vector,
-                const std::vector<NodeID> &total_packed_path,
-                const std::vector<std::size_t> &packed_leg_begin,
-                const EdgeWeight shortest_path_weight,
-                InternalRouteResult &raw_route_data)
-{
-    raw_route_data.unpacked_path_segments.resize(packed_leg_begin.size() - 1);
-
-    raw_route_data.shortest_path_weight = shortest_path_weight;
-
-    for (const auto current_leg : util::irange<std::size_t>(0UL, packed_leg_begin.size() - 1))
-    {
-        auto leg_begin = total_packed_path.begin() + packed_leg_begin[current_leg];
-        auto leg_end = total_packed_path.begin() + packed_leg_begin[current_leg + 1];
-        const auto &unpack_phantom_node_pair = phantom_nodes_vector[current_leg];
-        unpackPath(facade,
-                   leg_begin,
-                   leg_end,
-                   unpack_phantom_node_pair,
-                   raw_route_data.unpacked_path_segments[current_leg]);
-
-        raw_route_data.source_traversed_in_reverse.push_back(
-            (*leg_begin != phantom_nodes_vector[current_leg].source_phantom.forward_segment_id.id));
-        raw_route_data.target_traversed_in_reverse.push_back(
-            (*std::prev(leg_end) !=
-             phantom_nodes_vector[current_leg].target_phantom.forward_segment_id.id));
-    }
-}
-}
-
-template <typename Algorithm>
-InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                                       const DataFacade<Algorithm> &facade,
-                                       const std::vector<PhantomNodes> &phantom_nodes_vector,
-                                       const boost::optional<bool> continue_straight_at_waypoint)
-{
-    InternalRouteResult raw_route_data;
-    raw_route_data.segment_end_coordinates = phantom_nodes_vector;
-    const bool allow_uturn_at_waypoint =
-        !(continue_straight_at_waypoint ? *continue_straight_at_waypoint
-                                        : facade.GetContinueStraightDefault());
-
-    engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
-
-    auto &forward_heap = *engine_working_data.forward_heap_1;
-    auto &reverse_heap = *engine_working_data.reverse_heap_1;
-
-    int total_weight_to_forward = 0;
-    int total_weight_to_reverse = 0;
-    bool search_from_forward_node =
-        phantom_nodes_vector.front().source_phantom.IsValidForwardSource();
-    bool search_from_reverse_node =
-        phantom_nodes_vector.front().source_phantom.IsValidReverseSource();
-
-    std::vector<NodeID> prev_packed_leg_to_forward;
-    std::vector<NodeID> prev_packed_leg_to_reverse;
-
-    std::vector<NodeID> total_packed_path_to_forward;
-    std::vector<std::size_t> packed_leg_to_forward_begin;
-    std::vector<NodeID> total_packed_path_to_reverse;
-    std::vector<std::size_t> packed_leg_to_reverse_begin;
-
-    std::size_t current_leg = 0;
-    // this implements a dynamic program that finds the shortest route through
-    // a list of vias
-    for (const auto &phantom_node_pair : phantom_nodes_vector)
-    {
-        int new_total_weight_to_forward = INVALID_EDGE_WEIGHT;
-        int new_total_weight_to_reverse = INVALID_EDGE_WEIGHT;
-
-        std::vector<NodeID> packed_leg_to_forward;
-        std::vector<NodeID> packed_leg_to_reverse;
-
-        const auto &source_phantom = phantom_node_pair.source_phantom;
-        const auto &target_phantom = phantom_node_pair.target_phantom;
-
-        bool search_to_forward_node = target_phantom.IsValidForwardTarget();
-        bool search_to_reverse_node = target_phantom.IsValidReverseTarget();
-
-        BOOST_ASSERT(!search_from_forward_node || source_phantom.IsValidForwardSource());
-        BOOST_ASSERT(!search_from_reverse_node || source_phantom.IsValidReverseSource());
-
-        if (search_to_reverse_node || search_to_forward_node)
-        {
-            if (allow_uturn_at_waypoint)
-            {
-                searchWithUTurn(engine_working_data,
-                                facade,
-                                forward_heap,
-                                reverse_heap,
-                                search_from_forward_node,
-                                search_from_reverse_node,
-                                search_to_forward_node,
-                                search_to_reverse_node,
-                                source_phantom,
-                                target_phantom,
-                                total_weight_to_forward,
-                                total_weight_to_reverse,
-                                new_total_weight_to_forward,
-                                packed_leg_to_forward);
-                // if only the reverse node is valid (e.g. when using the match plugin) we
-                // actually need to move
-                if (!target_phantom.IsValidForwardTarget())
-                {
-                    BOOST_ASSERT(target_phantom.IsValidReverseTarget());
-                    new_total_weight_to_reverse = new_total_weight_to_forward;
-                    packed_leg_to_reverse = std::move(packed_leg_to_forward);
-                    new_total_weight_to_forward = INVALID_EDGE_WEIGHT;
-
-                    // (*)
-                    //
-                    //   Below we have to check if new_total_weight_to_forward is invalid.
-                    //   This prevents use-after-move on packed_leg_to_forward.
-                }
-                else if (target_phantom.IsValidReverseTarget())
-                {
-                    new_total_weight_to_reverse = new_total_weight_to_forward;
-                    packed_leg_to_reverse = packed_leg_to_forward;
-                }
-            }
-            else
-            {
-                search(engine_working_data,
-                       facade,
-                       forward_heap,
-                       reverse_heap,
-                       search_from_forward_node,
-                       search_from_reverse_node,
-                       search_to_forward_node,
-                       search_to_reverse_node,
-                       source_phantom,
-                       target_phantom,
-                       total_weight_to_forward,
-                       total_weight_to_reverse,
-                       new_total_weight_to_forward,
-                       new_total_weight_to_reverse,
-                       packed_leg_to_forward,
-                       packed_leg_to_reverse);
-            }
-        }
-
-        // Note: To make sure we do not access the moved-from packed_leg_to_forward
-        // we guard its access by a check for invalid edge weight. See  (*) above.
-
-        // No path found for both target nodes?
-        if ((INVALID_EDGE_WEIGHT == new_total_weight_to_forward) &&
-            (INVALID_EDGE_WEIGHT == new_total_weight_to_reverse))
-        {
-            return raw_route_data;
-        }
-
-        // we need to figure out how the new legs connect to the previous ones
-        if (current_leg > 0)
-        {
-            bool forward_to_forward =
-                (new_total_weight_to_forward != INVALID_EDGE_WEIGHT) &&
-                packed_leg_to_forward.front() == source_phantom.forward_segment_id.id;
-            bool reverse_to_forward =
-                (new_total_weight_to_forward != INVALID_EDGE_WEIGHT) &&
-                packed_leg_to_forward.front() == source_phantom.reverse_segment_id.id;
-            bool forward_to_reverse =
-                (new_total_weight_to_reverse != INVALID_EDGE_WEIGHT) &&
-                packed_leg_to_reverse.front() == source_phantom.forward_segment_id.id;
-            bool reverse_to_reverse =
-                (new_total_weight_to_reverse != INVALID_EDGE_WEIGHT) &&
-                packed_leg_to_reverse.front() == source_phantom.reverse_segment_id.id;
-
-            BOOST_ASSERT(!forward_to_forward || !reverse_to_forward);
-            BOOST_ASSERT(!forward_to_reverse || !reverse_to_reverse);
-
-            // in this case we always need to copy
-            if (forward_to_forward && forward_to_reverse)
-            {
-                // in this case we copy the path leading to the source forward node
-                // and change the case
-                total_packed_path_to_reverse = total_packed_path_to_forward;
-                packed_leg_to_reverse_begin = packed_leg_to_forward_begin;
-                forward_to_reverse = false;
-                reverse_to_reverse = true;
-            }
-            else if (reverse_to_forward && reverse_to_reverse)
-            {
-                total_packed_path_to_forward = total_packed_path_to_reverse;
-                packed_leg_to_forward_begin = packed_leg_to_reverse_begin;
-                reverse_to_forward = false;
-                forward_to_forward = true;
-            }
-            BOOST_ASSERT(!forward_to_forward || !forward_to_reverse);
-            BOOST_ASSERT(!reverse_to_forward || !reverse_to_reverse);
-
-            // in this case we just need to swap to regain the correct mapping
-            if (reverse_to_forward || forward_to_reverse)
-            {
-                total_packed_path_to_forward.swap(total_packed_path_to_reverse);
-                packed_leg_to_forward_begin.swap(packed_leg_to_reverse_begin);
-            }
-        }
-
-        if (new_total_weight_to_forward != INVALID_EDGE_WEIGHT)
-        {
-            BOOST_ASSERT(target_phantom.IsValidForwardTarget());
-
-            packed_leg_to_forward_begin.push_back(total_packed_path_to_forward.size());
-            total_packed_path_to_forward.insert(total_packed_path_to_forward.end(),
-                                                packed_leg_to_forward.begin(),
-                                                packed_leg_to_forward.end());
-            search_from_forward_node = true;
-        }
-        else
-        {
-            total_packed_path_to_forward.clear();
-            packed_leg_to_forward_begin.clear();
-            search_from_forward_node = false;
-        }
-
-        if (new_total_weight_to_reverse != INVALID_EDGE_WEIGHT)
-        {
-            BOOST_ASSERT(target_phantom.IsValidReverseTarget());
-
-            packed_leg_to_reverse_begin.push_back(total_packed_path_to_reverse.size());
-            total_packed_path_to_reverse.insert(total_packed_path_to_reverse.end(),
-                                                packed_leg_to_reverse.begin(),
-                                                packed_leg_to_reverse.end());
-            search_from_reverse_node = true;
-        }
-        else
-        {
-            total_packed_path_to_reverse.clear();
-            packed_leg_to_reverse_begin.clear();
-            search_from_reverse_node = false;
-        }
-
-        prev_packed_leg_to_forward = std::move(packed_leg_to_forward);
-        prev_packed_leg_to_reverse = std::move(packed_leg_to_reverse);
-
-        total_weight_to_forward = new_total_weight_to_forward;
-        total_weight_to_reverse = new_total_weight_to_reverse;
-
-        ++current_leg;
-    }
-
-    BOOST_ASSERT(total_weight_to_forward != INVALID_EDGE_WEIGHT ||
-                 total_weight_to_reverse != INVALID_EDGE_WEIGHT);
-
-    // We make sure the fastest route is always in packed_legs_to_forward
-    if (total_weight_to_forward < total_weight_to_reverse ||
-        (total_weight_to_forward == total_weight_to_reverse &&
-         total_packed_path_to_forward.size() < total_packed_path_to_reverse.size()))
-    {
-        // insert sentinel
-        packed_leg_to_forward_begin.push_back(total_packed_path_to_forward.size());
-        BOOST_ASSERT(packed_leg_to_forward_begin.size() == phantom_nodes_vector.size() + 1);
-
-        unpackLegs(facade,
-                   phantom_nodes_vector,
-                   total_packed_path_to_forward,
-                   packed_leg_to_forward_begin,
-                   total_weight_to_forward,
-                   raw_route_data);
-    }
-    else
-    {
-        // insert sentinel
-        packed_leg_to_reverse_begin.push_back(total_packed_path_to_reverse.size());
-        BOOST_ASSERT(packed_leg_to_reverse_begin.size() == phantom_nodes_vector.size() + 1);
-
-        unpackLegs(facade,
-                   phantom_nodes_vector,
-                   total_packed_path_to_reverse,
-                   packed_leg_to_reverse_begin,
-                   total_weight_to_reverse,
-                   raw_route_data);
-    }
-
-    return raw_route_data;
-}
-
 template InternalRouteResult
 shortestPathSearch(SearchEngineData<ch::Algorithm> &engine_working_data,
                    const DataFacade<ch::Algorithm> &facade,

src/extractor/compressed_edge_container.cpp

@@ -103,14 +103,17 @@ SegmentDuration CompressedEdgeContainer::ClipDuration(const SegmentDuration dura
 //   ----------> via_node_id -----------> target_node_id
 //     weight_1                weight_2
 //     duration_1              duration_2
-void CompressedEdgeContainer::CompressEdge(const EdgeID edge_id_1,
-                                           const EdgeID edge_id_2,
-                                           const NodeID via_node_id,
-                                           const NodeID target_node_id,
-                                           const EdgeWeight weight1,
-                                           const EdgeWeight weight2,
-                                           const EdgeDuration duration1,
-                                           const EdgeDuration duration2)
+void CompressedEdgeContainer::CompressEdge(
+    const EdgeID edge_id_1,
+    const EdgeID edge_id_2,
+    const NodeID via_node_id,
+    const NodeID target_node_id,
+    const EdgeWeight weight1,
+    const EdgeWeight weight2,
+    const EdgeDuration duration1,
+    const EdgeDuration duration2,
+    const boost::optional<EdgeWeight> node_weight_penalty,
+    const boost::optional<EdgeDuration> node_duration_penalty)
 {
     // remove super-trivial geometries
     BOOST_ASSERT(SPECIAL_EDGEID != edge_id_1);
@@ -151,9 +154,11 @@ void CompressedEdgeContainer::CompressEdge(const EdgeID edge_id_1,
     std::vector<OnewayCompressedEdge> &edge_bucket_list1 =
         m_compressed_oneway_geometries[edge_bucket_id1];
 
+    bool was_empty = edge_bucket_list1.empty();
+
     // note we don't save the start coordinate: it is implicitly given by edge 1
     // weight1 is the distance to the (currently) last coordinate in the bucket
-    if (edge_bucket_list1.empty())
+    if (was_empty)
     {
         edge_bucket_list1.emplace_back(
             OnewayCompressedEdge{via_node_id, ClipWeight(weight1), ClipDuration(duration1)});
@@ -162,6 +167,14 @@ void CompressedEdgeContainer::CompressEdge(const EdgeID edge_id_1,
     BOOST_ASSERT(0 < edge_bucket_list1.size());
     BOOST_ASSERT(!edge_bucket_list1.empty());
 
+    // if the via-node offers a penalty, we add the weight of the penalty as an artificial
+    // segment that references SPECIAL_NODEID
+    if (node_weight_penalty && node_duration_penalty)
+    {
+        edge_bucket_list1.emplace_back(OnewayCompressedEdge{
+            via_node_id, ClipWeight(*node_weight_penalty), ClipDuration(*node_duration_penalty)});
+    }
+
     if (HasEntryForID(edge_id_2))
     {
         // second edge is not atomic anymore

src/extractor/edge_based_graph_factory.cpp

@@ -1,4 +1,5 @@
 #include "extractor/edge_based_graph_factory.hpp"
+#include "extractor/conditional_turn_penalty.hpp"
 #include "extractor/edge_based_edge.hpp"
 #include "extractor/files.hpp"
 #include "extractor/guidance/turn_analysis.hpp"
@@ -6,6 +7,7 @@
 #include "extractor/scripting_environment.hpp"
 #include "extractor/suffix_table.hpp"
 
+#include "extractor/serialization.hpp"
 #include "storage/io.hpp"
 
 #include "util/assert.hpp"
@@ -20,8 +22,10 @@
 #include "util/timing_util.hpp"
 
 #include <boost/assert.hpp>
+#include <boost/functional/hash.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 
+#include "boost/unordered_map.hpp"
 #include <algorithm>
 #include <cmath>
 #include <iomanip>
@@ -35,12 +39,26 @@
 #include <tbb/pipeline.h>
 #include <tbb/task_scheduler_init.h>
 
+namespace std
+{
+template <> struct hash<std::pair<NodeID, NodeID>>
+{
+    std::size_t operator()(const std::pair<NodeID, NodeID> &mk) const noexcept
+    {
+        std::size_t seed = 0;
+        boost::hash_combine(seed, mk.first);
+        boost::hash_combine(seed, mk.second);
+        return seed;
+    }
+};
+}
+
 namespace osrm
 {
 namespace extractor
 {
-// Configuration to find representative candidate for turn angle calculations
 
+// Configuration to find representative candidate for turn angle calculations
 EdgeBasedGraphFactory::EdgeBasedGraphFactory(
     std::shared_ptr<util::NodeBasedDynamicGraph> node_based_graph,
     CompressedEdgeContainer &compressed_edge_container,
@@ -168,6 +186,11 @@ NBGToEBG EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const N
             m_compressed_edge_container.GetBucketReference(edge_id_2)[segment_count - 1 - i]
                 .node_id);
         const NodeID current_edge_target_coordinate_id = forward_geometry[i].node_id;
+
+        // don't add node-segments for penalties
+        if (current_edge_target_coordinate_id == current_edge_source_coordinate_id)
+            continue;
+
         BOOST_ASSERT(current_edge_target_coordinate_id != current_edge_source_coordinate_id);
 
         // build edges
@@ -194,7 +217,9 @@ void EdgeBasedGraphFactory::Run(ScriptingEnvironment &scripting_environment,
                                 const std::string &turn_duration_penalties_filename,
                                 const std::string &turn_penalties_index_filename,
                                 const std::string &cnbg_ebg_mapping_path,
+                                const std::string &conditional_penalties_filename,
                                 const RestrictionMap &node_restriction_map,
+                                const ConditionalRestrictionMap &conditional_node_restriction_map,
                                 const WayRestrictionMap &way_restriction_map)
 {
     TIMER_START(renumber);
@@ -215,7 +240,9 @@ void EdgeBasedGraphFactory::Run(ScriptingEnvironment &scripting_environment,
                               turn_weight_penalties_filename,
                               turn_duration_penalties_filename,
                               turn_penalties_index_filename,
+                              conditional_penalties_filename,
                               node_restriction_map,
+                              conditional_node_restriction_map,
                               way_restriction_map);
 
     TIMER_STOP(generate_edges);
@@ -379,7 +406,9 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
     const std::string &turn_weight_penalties_filename,
     const std::string &turn_duration_penalties_filename,
     const std::string &turn_penalties_index_filename,
+    const std::string &conditional_penalties_filename,
     const RestrictionMap &node_restriction_map,
+    const ConditionalRestrictionMap &conditional_restriction_map,
     const WayRestrictionMap &way_restriction_map)
 {
 
@@ -422,6 +451,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
     const auto weight_multiplier =
         scripting_environment.GetProfileProperties().GetWeightMultiplier();
 
+    // filled in during next stage, kept alive through following scope
+    std::vector<Conditional> conditionals;
     // The following block generates the edge-based-edges using a parallel processing
     // pipeline.  Sets of intersection IDs are batched in groups of GRAINSIZE (100)
     // `generator_stage`,
@@ -477,7 +508,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
         };
 
         // same as IntersectionData, but grouped with edge to allow sorting after creating. Edges
-        // are out of order
+        // can be out of order
         struct EdgeWithData
         {
             EdgeBasedEdge edge;
@@ -492,10 +523,14 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             std::size_t nodes_processed = 0;
             IntersectionData continuous_data;
             std::vector<EdgeWithData> delayed_data;
+            std::vector<Conditional> conditionals;
         };
 
         // Generate edges for either artificial nodes or the main graph
-        const auto generate_edge = [this, &scripting_environment, weight_multiplier](
+        const auto generate_edge = [this,
+                                    &scripting_environment,
+                                    weight_multiplier,
+                                    &conditional_restriction_map](
             // what nodes will be used? In most cases this will be the id stored in the edge_data.
             // In case of duplicated nodes (e.g. due to via-way restrictions), one/both of these
             // might refer to a newly added edge based node
@@ -509,6 +544,24 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             const auto &intersection,
             const auto &turn,
             const auto entry_class_id) {
+
+            const auto node_restricted = isRestricted(node_along_road_entering,
+                                                      node_at_center_of_intersection,
+                                                      m_node_based_graph->GetTarget(turn.eid),
+                                                      conditional_restriction_map);
+
+            boost::optional<Conditional> conditional = boost::none;
+            if (node_restricted.first)
+            {
+                auto const &conditions = node_restricted.second->condition;
+                // get conditions of the restriction limiting the node
+                conditional = {{edge_based_node_from,
+                                edge_based_node_to,
+                                {static_cast<std::uint64_t>(-1),
+                                 m_coordinates[node_at_center_of_intersection],
+                                 conditions}}};
+            }
+
             const EdgeData &edge_data1 = m_node_based_graph->GetEdgeData(node_based_edge_from);
             const EdgeData &edge_data2 = m_node_based_graph->GetEdgeData(node_based_edge_to);
 
@@ -568,15 +621,16 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             const auto &from_node =
                 isTrivial ? node_along_road_entering
                           : m_compressed_edge_container.GetLastEdgeSourceID(node_based_edge_from);
-            const auto &via_node =
-                m_compressed_edge_container.GetLastEdgeTargetID(node_based_edge_from);
             const auto &to_node = m_compressed_edge_container.GetFirstEdgeTargetID(turn.eid);
 
-            lookup::TurnIndexBlock turn_index_block = {from_node, via_node, to_node};
+            lookup::TurnIndexBlock turn_index_block = {
+                from_node, node_at_center_of_intersection, to_node};
 
             // insert data into the designated buffer
-            return EdgeWithData{
-                edge_based_edge, turn_index_block, weight_penalty, duration_penalty, turn_data};
+            return std::make_pair(
+                EdgeWithData{
+                    edge_based_edge, turn_index_block, weight_penalty, duration_penalty, turn_data},
+                conditional);
         };
 
         // Second part of the pipeline is where the intersection analysis is done for
@@ -715,7 +769,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                 m_number_of_edge_based_nodes);
 
                             { // scope to forget edge_with_data after
-                                const auto edge_with_data =
+                                const auto edge_with_data_and_condition =
                                     generate_edge(edge_data1.edge_id,
                                                   target_id,
                                                   node_along_road_entering,
@@ -726,15 +780,21 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                                   turn,
                                                   entry_class_id);
 
-                                buffer->continuous_data.edges_list.push_back(edge_with_data.edge);
+                                buffer->continuous_data.edges_list.push_back(
+                                    edge_with_data_and_condition.first.edge);
                                 buffer->continuous_data.turn_indexes.push_back(
-                                    edge_with_data.turn_index);
+                                    edge_with_data_and_condition.first.turn_index);
                                 buffer->continuous_data.turn_weight_penalties.push_back(
-                                    edge_with_data.turn_weight_penalty);
+                                    edge_with_data_and_condition.first.turn_weight_penalty);
                                 buffer->continuous_data.turn_duration_penalties.push_back(
-                                    edge_with_data.turn_duration_penalty);
+                                    edge_with_data_and_condition.first.turn_duration_penalty);
                                 buffer->continuous_data.turn_data_container.push_back(
-                                    edge_with_data.turn_data);
+                                    edge_with_data_and_condition.first.turn_data);
+                                if (edge_with_data_and_condition.second)
+                                {
+                                    buffer->conditionals.push_back(
+                                        *edge_with_data_and_condition.second);
+                                }
                             }
 
                             // when turning off a a via-way turn restriction, we need to not only
@@ -749,24 +809,30 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                 // next to the normal restrictions tracked in `entry_allowed`, via
                                 // ways might introduce additional restrictions. These are handled
                                 // here when turning off a via-way
-                                const auto add_unrestricted_turns =
-                                    [&](const auto duplicated_node_id) {
-                                        const auto from_id =
-                                            m_number_of_edge_based_nodes -
-                                            way_restriction_map.NumberOfDuplicatedNodes() +
-                                            duplicated_node_id;
+                                for (auto duplicated_node_id : duplicated_nodes)
+                                {
+                                    const auto from_id =
+                                        m_number_of_edge_based_nodes -
+                                        way_restriction_map.NumberOfDuplicatedNodes() +
+                                        duplicated_node_id;
 
-                                        auto const node_at_end_of_turn =
-                                            m_node_based_graph->GetTarget(turn.eid);
+                                    auto const node_at_end_of_turn =
+                                        m_node_based_graph->GetTarget(turn.eid);
 
-                                        const auto is_restricted = way_restriction_map.IsRestricted(
+                                    const auto is_way_restricted = way_restriction_map.IsRestricted(
+                                        duplicated_node_id, node_at_end_of_turn);
+
+                                    if (is_way_restricted)
+                                    {
+
+                                        auto const restriction = way_restriction_map.GetRestriction(
                                             duplicated_node_id, node_at_end_of_turn);
 
-                                        if (is_restricted)
-                                            return;
+                                        if (restriction.condition.empty())
+                                            continue;
 
                                         // add into delayed data
-                                        auto edge_with_data = generate_edge(
+                                        auto edge_with_data_and_condition = generate_edge(
                                             NodeID(from_id),
                                             m_node_based_graph->GetEdgeData(turn.eid).edge_id,
                                             node_along_road_entering,
@@ -777,12 +843,50 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                             turn,
                                             entry_class_id);
 
-                                        buffer->delayed_data.push_back(std::move(edge_with_data));
-                                    };
+                                        buffer->delayed_data.push_back(
+                                            std::move(edge_with_data_and_condition.first));
 
-                                std::for_each(duplicated_nodes.begin(),
-                                              duplicated_nodes.end(),
-                                              add_unrestricted_turns);
+                                        if (edge_with_data_and_condition.second)
+                                        {
+                                            buffer->conditionals.push_back(
+                                                *edge_with_data_and_condition.second);
+                                        }
+
+                                        // also add the conditions for the way
+                                        if (is_way_restricted && !restriction.condition.empty())
+                                        {
+                                            // add a new conditional for the edge we just created
+                                            buffer->conditionals.push_back(
+                                                {NodeID(from_id),
+                                                 m_node_based_graph->GetEdgeData(turn.eid).edge_id,
+                                                 {static_cast<std::uint64_t>(-1),
+                                                  m_coordinates[node_at_center_of_intersection],
+                                                  restriction.condition}});
+                                        }
+                                    }
+                                    else
+                                    {
+                                        auto edge_with_data_and_condition = generate_edge(
+                                            NodeID(from_id),
+                                            m_node_based_graph->GetEdgeData(turn.eid).edge_id,
+                                            node_along_road_entering,
+                                            incoming_edge,
+                                            node_at_center_of_intersection,
+                                            turn.eid,
+                                            intersection,
+                                            turn,
+                                            entry_class_id);
+
+                                        buffer->delayed_data.push_back(
+                                            std::move(edge_with_data_and_condition.first));
+
+                                        if (edge_with_data_and_condition.second)
+                                        {
+                                            buffer->conditionals.push_back(
+                                                *edge_with_data_and_condition.second);
+                                        }
+                                    }
+                                }
                             }
                         }
                     }
@@ -826,6 +930,9 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                                  data.turn_indexes.begin(),
                                                  data.turn_indexes.end());
 
+                conditionals.insert(
+                    conditionals.end(), buffer->conditionals.begin(), buffer->conditionals.end());
+
                 // Buffer writes to reduce syscall count
                 if (turn_indexes_write_buffer.size() >= TURN_INDEX_WRITE_BUFFER_SIZE)
                 {
@@ -878,6 +985,20 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                           }
                       });
 
+    // re-hash conditionals to ocnnect to their respective edge-based edges. Due to the
+    // ordering, we
+    // do not really have a choice but to index the conditional penalties and walk over all
+    // edge-based-edges to find the ID of the edge
+    auto const indexed_conditionals = IndexConditionals(std::move(conditionals));
+    {
+        util::Log() << "Writing " << indexed_conditionals.size()
+                    << " conditional turn penalties...";
+        // write conditional turn penalties into the restrictions file
+        storage::io::FileWriter writer(conditional_penalties_filename,
+                                       storage::io::FileWriter::GenerateFingerprint);
+        extractor::serialization::write(writer, indexed_conditionals);
+    }
+
     // write weight penalties per turn
     BOOST_ASSERT(turn_weight_penalties.size() == turn_duration_penalties.size());
     {
@@ -917,11 +1038,36 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
     util::Log() << "  contains " << m_edge_based_edge_list.size() << " edges";
     util::Log() << "  skips " << restricted_turns_counter << " turns, "
                                                              "defined by "
-                << node_restriction_map.size() << " restrictions";
+                << node_restriction_map.Size() << " restrictions";
     util::Log() << "  skips " << skipped_uturns_counter << " U turns";
     util::Log() << "  skips " << skipped_barrier_turns_counter << " turns over barriers";
 }
 
+std::vector<ConditionalTurnPenalty>
+EdgeBasedGraphFactory::IndexConditionals(std::vector<Conditional> &&conditionals) const
+{
+    boost::unordered_multimap<std::pair<NodeID, NodeID>, ConditionalTurnPenalty *> index;
+
+    // build and index of all conditional restrictions
+    for (auto &conditional : conditionals)
+        index.insert(std::make_pair(std::make_pair(conditional.from_node, conditional.to_node),
+                                    &conditional.penalty));
+
+    std::vector<ConditionalTurnPenalty> indexed_restrictions;
+
+    for (auto const &edge : m_edge_based_edge_list)
+    {
+        auto const range = index.equal_range(std::make_pair(edge.source, edge.target));
+        for (auto itr = range.first; itr != range.second; ++itr)
+        {
+            itr->second->turn_offset = edge.data.turn_id;
+            indexed_restrictions.push_back(*itr->second);
+        }
+    }
+
+    return indexed_restrictions;
+}
+
 std::vector<util::guidance::BearingClass> EdgeBasedGraphFactory::GetBearingClasses() const
 {
     std::vector<util::guidance::BearingClass> result(bearing_class_hash.data.size());

src/extractor/extraction_containers.cpp

@@ -126,7 +126,6 @@ ExtractionContainers::ExtractionContainers()
  */
 void ExtractionContainers::PrepareData(ScriptingEnvironment &scripting_environment,
                                        const std::string &osrm_path,
-                                       const std::string &restrictions_file_name,
                                        const std::string &name_file_name)
 {
     storage::io::FileWriter file_out(osrm_path, storage::io::FileWriter::GenerateFingerprint);
@@ -139,7 +138,6 @@ void ExtractionContainers::PrepareData(ScriptingEnvironment &scripting_environme
     WriteEdges(file_out);
 
     PrepareRestrictions();
-    WriteConditionalRestrictions(restrictions_file_name);
     WriteCharData(name_file_name);
 }
 
@@ -616,33 +614,23 @@ void ExtractionContainers::WriteNodes(storage::io::FileWriter &file_out) const
         util::UnbufferedLog log;
         log << "Writing traffic light nodes     ... ";
         TIMER_START(write_nodes);
-        std::vector<NodeID> internal_traffic_lights;
-        for (const auto osm_id : traffic_lights)
+        std::vector<NodeID> internal_traffic_signals;
+        for (const auto osm_id : traffic_signals)
         {
             const auto node_id = mapExternalToInternalNodeID(
                 used_node_id_list.begin(), used_node_id_list.end(), osm_id);
             if (node_id != SPECIAL_NODEID)
             {
-                internal_traffic_lights.push_back(node_id);
+                internal_traffic_signals.push_back(node_id);
             }
         }
-        storage::serialization::write(file_out, internal_traffic_lights);
+        storage::serialization::write(file_out, internal_traffic_signals);
         log << "ok, after " << TIMER_SEC(write_nodes) << "s";
     }
 
     util::Log() << "Processed " << max_internal_node_id << " nodes";
 }
 
-void ExtractionContainers::WriteConditionalRestrictions(const std::string &path)
-{
-    std::uint64_t written_restriction_count = conditional_turn_restrictions.size();
-    storage::io::FileWriter restrictions_out_file(path,
-                                                  storage::io::FileWriter::GenerateFingerprint);
-    serialization::write(restrictions_out_file, conditional_turn_restrictions);
-    util::Log() << "number of conditional restrictions written to disk: "
-                << written_restriction_count;
-}
-
 void ExtractionContainers::PrepareRestrictions()
 {
 
@@ -765,7 +753,7 @@ void ExtractionContainers::PrepareRestrictions()
     // translate the turn from one segment onto another into a node restriction (the ways can only
     // be connected at a single location)
     auto const get_node_restriction_from_OSM_ids = [&](
-        auto const from_id, auto const to_id, const OSMNodeID via_node = MAX_OSM_NODEID) {
+        auto const from_id, auto const to_id, const OSMNodeID via_node) {
         auto const from_segment_itr = referenced_ways.find(from_id);
         if (from_segment_itr->second.way_id != from_id)
         {
@@ -792,9 +780,9 @@ void ExtractionContainers::PrepareRestrictions()
             auto const &external = external_type.AsWayRestriction();
             // check if we were able to resolve all the involved ways
             auto const from_restriction =
-                get_node_restriction_from_OSM_ids(external.from, external.via);
+                get_node_restriction_from_OSM_ids(external.from, external.via, MAX_OSM_NODEID);
             auto const to_restriction =
-                get_node_restriction_from_OSM_ids(external.via, external.to);
+                get_node_restriction_from_OSM_ids(external.via, external.to, MAX_OSM_NODEID);
 
             // failed to translate either of the involved nodes?
             if (!from_restriction.Valid() || !to_restriction.Valid())
@@ -837,7 +825,8 @@ void ExtractionContainers::PrepareRestrictions()
     const auto transform_into_internal_types =
         [&](const InputConditionalTurnRestriction &external_restriction) {
             // unconditional restriction
-            if (external_restriction.condition.empty())
+            if (external_restriction.condition.empty() &&
+                external_restriction.Type() == RestrictionType::NODE_RESTRICTION)
             {
                 TurnRestriction restriction;
                 restriction.is_only = external_restriction.is_only;
@@ -851,7 +840,9 @@ void ExtractionContainers::PrepareRestrictions()
                 restriction.is_only = external_restriction.is_only;
                 restriction.condition = std::move(external_restriction.condition);
                 if (transform(external_restriction, restriction))
+                {
                     conditional_turn_restrictions.push_back(std::move(restriction));
+                }
             }
         };
 

src/extractor/extractor.cpp

@@ -23,7 +23,7 @@
 #include "util/timing_util.hpp"
 
 #include "extractor/compressed_edge_container.hpp"
-#include "extractor/restriction_map.hpp"
+#include "extractor/restriction_index.hpp"
 #include "extractor/way_restriction_map.hpp"
 #include "util/static_graph.hpp"
 #include "util/static_rtree.hpp"
@@ -110,7 +110,8 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
 
     guidance::LaneDescriptionMap turn_lane_map;
     std::vector<TurnRestriction> turn_restrictions;
-    std::tie(turn_lane_map, turn_restrictions) =
+    std::vector<ConditionalTurnRestriction> conditional_turn_restrictions;
+    std::tie(turn_lane_map, turn_restrictions, conditional_turn_restrictions) =
         ParseOSMData(scripting_environment, number_of_threads);
 
     // Transform the node-based graph that OSM is based on into an edge-based graph
@@ -138,6 +139,7 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
                                              edge_based_edge_list,
                                              config.GetPath(".osrm.icd").string(),
                                              turn_restrictions,
+                                             conditional_turn_restrictions,
                                              turn_lane_map);
 
     auto number_of_node_based_nodes = graph_size.first;
@@ -190,7 +192,9 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
     return 0;
 }
 
-std::tuple<guidance::LaneDescriptionMap, std::vector<TurnRestriction>>
+std::tuple<guidance::LaneDescriptionMap,
+           std::vector<TurnRestriction>,
+           std::vector<ConditionalTurnRestriction>>
 Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
                         const unsigned number_of_threads)
 {
@@ -333,7 +337,6 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
 
     extraction_containers.PrepareData(scripting_environment,
                                       config.GetPath(".osrm").string(),
-                                      config.GetPath(".osrm.restrictions").string(),
                                       config.GetPath(".osrm.names").string());
 
     auto profile_properties = scripting_environment.GetProfileProperties();
@@ -344,7 +347,8 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
     util::Log() << "extraction finished after " << TIMER_SEC(extracting) << "s";
 
     return std::make_tuple(std::move(turn_lane_map),
-                           std::move(extraction_containers.unconditional_turn_restrictions));
+                           std::move(extraction_containers.unconditional_turn_restrictions),
+                           std::move(extraction_containers.conditional_turn_restrictions));
 }
 
 void Extractor::FindComponents(unsigned max_edge_id,
@@ -440,41 +444,45 @@ Extractor::LoadNodeBasedGraph(std::unordered_set<NodeID> &barriers,
 /**
  \brief Building an edge-expanded graph from node-based input and turn restrictions
 */
-std::pair<std::size_t, EdgeID>
-Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
-                                  std::vector<util::Coordinate> &coordinates,
-                                  extractor::PackedOSMIDs &osm_node_ids,
-                                  EdgeBasedNodeDataContainer &edge_based_nodes_container,
-                                  std::vector<EdgeBasedNodeSegment> &edge_based_node_segments,
-                                  std::vector<bool> &node_is_startpoint,
-                                  std::vector<EdgeWeight> &edge_based_node_weights,
-                                  util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
-                                  const std::string &intersection_class_output_file,
-                                  std::vector<TurnRestriction> &turn_restrictions,
-                                  guidance::LaneDescriptionMap &turn_lane_map)
+std::pair<std::size_t, EdgeID> Extractor::BuildEdgeExpandedGraph(
+    ScriptingEnvironment &scripting_environment,
+    std::vector<util::Coordinate> &coordinates,
+    extractor::PackedOSMIDs &osm_node_ids,
+    EdgeBasedNodeDataContainer &edge_based_nodes_container,
+    std::vector<EdgeBasedNodeSegment> &edge_based_node_segments,
+    std::vector<bool> &node_is_startpoint,
+    std::vector<EdgeWeight> &edge_based_node_weights,
+    util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
+    const std::string &intersection_class_output_file,
+    std::vector<TurnRestriction> &turn_restrictions,
+    std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
+    guidance::LaneDescriptionMap &turn_lane_map)
 {
     std::unordered_set<NodeID> barrier_nodes;
-    std::unordered_set<NodeID> traffic_lights;
+    std::unordered_set<NodeID> traffic_signals;
 
     auto node_based_graph =
-        LoadNodeBasedGraph(barrier_nodes, traffic_lights, coordinates, osm_node_ids);
+        LoadNodeBasedGraph(barrier_nodes, traffic_signals, coordinates, osm_node_ids);
 
     CompressedEdgeContainer compressed_edge_container;
     GraphCompressor graph_compressor;
     graph_compressor.Compress(barrier_nodes,
-                              traffic_lights,
+                              traffic_signals,
+                              scripting_environment,
                               turn_restrictions,
+                              conditional_turn_restrictions,
                               *node_based_graph,
                               compressed_edge_container);
 
-    turn_restrictions = removeInvalidRestrictions(std::move(turn_restrictions), *node_based_graph);
+    conditional_turn_restrictions =
+        removeInvalidRestrictions(std::move(conditional_turn_restrictions), *node_based_graph);
 
     util::NameTable name_table(config.GetPath(".osrm.names").string());
 
     EdgeBasedGraphFactory edge_based_graph_factory(node_based_graph,
                                                    compressed_edge_container,
                                                    barrier_nodes,
-                                                   traffic_lights,
+                                                   traffic_signals,
                                                    coordinates,
                                                    osm_node_ids,
                                                    scripting_environment.GetProfileProperties(),
@@ -483,8 +491,20 @@ Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
 
     const auto create_edge_based_edges = [&]() {
         // scoped to relase intermediate datastructures right after the call
-        RestrictionMap via_node_restriction_map(turn_restrictions);
-        WayRestrictionMap via_way_restriction_map(turn_restrictions);
+        std::vector<TurnRestriction> node_restrictions;
+        for (auto const &t : turn_restrictions)
+            if (t.Type() == RestrictionType::NODE_RESTRICTION)
+                node_restrictions.push_back(t);
+
+        std::vector<ConditionalTurnRestriction> conditional_node_restrictions;
+        for (auto const &t : conditional_turn_restrictions)
+            if (t.Type() == RestrictionType::NODE_RESTRICTION)
+                conditional_node_restrictions.push_back(t);
+
+        RestrictionMap via_node_restriction_map(node_restrictions, IndexNodeByFromAndVia());
+        WayRestrictionMap via_way_restriction_map(conditional_turn_restrictions);
+        ConditionalRestrictionMap conditional_node_restriction_map(conditional_node_restrictions,
+                                                                   IndexNodeByFromAndVia());
         turn_restrictions.clear();
         turn_restrictions.shrink_to_fit();
 
@@ -495,13 +515,14 @@ Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
                                      config.GetPath(".osrm.turn_duration_penalties").string(),
                                      config.GetPath(".osrm.turn_penalties_index").string(),
                                      config.GetPath(".osrm.cnbg_to_ebg").string(),
+                                     config.GetPath(".osrm.restrictions").string(),
                                      via_node_restriction_map,
+                                     conditional_node_restriction_map,
                                      via_way_restriction_map);
         return edge_based_graph_factory.GetNumberOfEdgeBasedNodes();
     };
 
     const auto number_of_edge_based_nodes = create_edge_based_edges();
-
     compressed_edge_container.PrintStatistics();
 
     // The osrm-partition tool requires the compressed node based graph with an embedding.

src/extractor/extractor_callbacks.cpp

@@ -69,7 +69,7 @@ void ExtractorCallbacks::ProcessNode(const osmium::Node &input_node,
     }
     if (result_node.traffic_lights)
     {
-        external_memory.traffic_lights.push_back(id);
+        external_memory.traffic_signals.push_back(id);
     }
 }