Compare commits
20 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Patrick Niklaus
|
2cc293ad16 | ||
|
Patrick Niklaus
|
6ac65a922f | ||
|
Patrick Niklaus
|
3d80f989d0 | ||
 Patrick Niklaus
|
4fcb5d28a4 | ||
|
Patrick Niklaus
|
3ebdacf369 | ||
 Moritz Kobitzsch
|
2ddc00c21e | ||
 Daniel J. Hofmann
|
e76e39a398 | ||
|
Patrick Niklaus
|
04667f1ed8 | ||
 Surya Suluh
|
2091c3443b | ||
 Michael Krasnyk
|
2b466b2fb2 | ||
|
Michael Krasnyk
|
e17b306265 | ||
|
Daniel J. Hofmann
|
b00b15ab98 | ||
|
Moritz Kobitzsch
|
f4db79fe9b | ||
|
Moritz Kobitzsch
|
0e4061f858 | ||
|
Moritz Kobitzsch
|
043a1446e1 | ||
|
Moritz Kobitzsch
|
49221995e8 | ||
|
Moritz Kobitzsch
|
247a7488b8 | ||
|
Moritz Kobitzsch
|
1806198971 | ||
|
Moritz Kobitzsch
|
375331b80c | ||
|
Patrick Niklaus
|
8fdbe965cc |
+4
-3
@@ -75,9 +75,10 @@ matrix:
|
||||
compiler: "gcc-5-release-i686"
|
||||
env: TARGET_ARCH='i686' CCOMPILER='gcc-5' CXXCOMPILER='g++-5' BUILD_TYPE='Release'
|
||||
|
||||
- os: linux
|
||||
compiler: "gcc-4.8-release-armhf"
|
||||
env: TARGET_ARCH='armhf' CCOMPILER='arm-linux-gnueabihf-gcc-4.8' CXXCOMPILER='arm-linux-gnueabihf-g++-4.8' BUILD_TYPE='Release'
|
||||
# FIXME disabled until sourceforge fixes its packages for stxxl
|
||||
#- os: linux
|
||||
#- compiler: "gcc-4.8-release-armhf"
|
||||
#- env: TARGET_ARCH='armhf' CCOMPILER='arm-linux-gnueabihf-gcc-4.8' CXXCOMPILER='arm-linux-gnueabihf-g++-4.8' BUILD_TYPE='Release'
|
||||
|
||||
# Disabled because of CI slowness
|
||||
#- os: linux
|
||||
|
||||
+15
-2
@@ -1,11 +1,24 @@
|
||||
# 5.3.0
|
||||
# 5.3.0 RC3
|
||||
Changes from 5.3.0-rc.2
|
||||
- Guidance
|
||||
- Improved detection of obvious turns
|
||||
- Improved turn lane detection
|
||||
- Bugfixes
|
||||
- Fix bug that didn't chose minimal weights on overlapping edges
|
||||
|
||||
# 5.3.0 RC2
|
||||
Changes from 5.3.0-rc.1
|
||||
- Bugfixes
|
||||
- Fixes invalid checks in the lane-extraction part of the car profile
|
||||
|
||||
# 5.3.0 RC1
|
||||
- API
|
||||
- Introduces new `TurnType` in the form of `use lane`. The type indicates that you have to stick to a lane without turning
|
||||
- Introduces lanes to the route response. The lane data contains both the markings at the intersection and a flag indicating their involvement in the turn
|
||||
|
||||
- Infrastructure
|
||||
- BREAKING: The new turn type changes the turn-type order. This breaks the **data format**.
|
||||
- BREAKING: Turn lane data introduces a new file (osrm.tld). This breaks the fileformat for older versions.
|
||||
- BREAKING: Turn lane data introduces two new files (osrm.tld,osrm.tls). This breaks the fileformat for older versions.
|
||||
|
||||
# 5.2.5
|
||||
- Bugfixes
|
||||
|
||||
+34
-33
@@ -357,7 +357,7 @@ Three input coordinates, `geometry=geojson`, `steps=false`:
|
||||
{
|
||||
"distance": 90.0,
|
||||
"duration": 300.0,
|
||||
"geometry": {"type": "LineString", "coordinates": [[120., 10.], [120.1, 10.], [120.2, 10.], [120.3, 10.]]},
|
||||
"geometry": {"type": "LineString", "coordinates": [[120.0, 10.0], [120.1, 10.0], [120.2, 10.0], [120.3, 10.0]]},
|
||||
"legs": [
|
||||
{
|
||||
"distance": 30.0,
|
||||
@@ -410,7 +410,7 @@ With `steps=false` and `annotations=true`:
|
||||
{
|
||||
"distance": 30.0,
|
||||
"duration": 100.0,
|
||||
"steps": []
|
||||
"steps": [],
|
||||
"annotation": {
|
||||
"distance": [5,5,10,5,5],
|
||||
"duration": [15,15,40,15,15],
|
||||
@@ -486,23 +486,24 @@ step.
|
||||
- `type` A string indicating the type of maneuver. **new identifiers might be introduced without API change**
|
||||
Types unknown to the client should be handled like the `turn` type, the existance of correct `modifier` values is guranteed.
|
||||
|
||||
| `type` | Description |
|
||||
|-------------------|--------------------------------------------------------------|
|
||||
| turn | a basic turn into direction of the `modifier` |
|
||||
| new name | no turn is taken/possible, but the road name changes. The road can take a turn itself, following `modifier`. |
|
||||
| depart | indicates the departure of the leg |
|
||||
| arrive | indicates the destination of the leg |
|
||||
| merge | merge onto a street (e.g. getting on the highway from a ramp, the `modifier specifies the direction of the merge`) |
|
||||
| ramp | **Deprecated**. Replaced by `on_ramp` and `off_ramp`. |
|
||||
| on ramp | take a ramp to enter a highway (direction given my `modifier`) |
|
||||
| off ramp | take a ramp to exit a highway (direction given my `modifier`) |
|
||||
| fork | take the left/right side at a fork depending on `modifier` |
|
||||
| end of road | road ends in a T intersection turn in direction of `modifier`|
|
||||
| continue | Turn in direction of `modifier` to stay on the same road |
|
||||
| roundabout | traverse roundabout, has additional field `exit` with NR if the roundabout is left. `the modifier specifies the direction of entering the roundabout` |
|
||||
| rotary | a larger version of a roundabout, can offer `rotary_name` in addition to the `exit` parameter. |
|
||||
| roundabout turn | Describes a turn at a small roundabout that should be treated as normal turn. The `modifier` indicates the turn direciton. Example instruction: `At the roundabout turn left`. |
|
||||
| notification | not an actual turn but a change in the driving conditions. For example the travel mode. If the road takes a turn itself, the `modifier` describes the direction |
|
||||
| `type` | Description |
|
||||
|------------------|--------------------------------------------------------------|
|
||||
| `turn` | a basic turn into direction of the `modifier` |
|
||||
| `new name` | no turn is taken/possible, but the road name changes. The road can take a turn itself, following `modifier`. |
|
||||
| `depart` | indicates the departure of the leg |
|
||||
| `arrive` | indicates the destination of the leg |
|
||||
| `merge` | merge onto a street (e.g. getting on the highway from a ramp, the `modifier specifies the direction of the merge`) |
|
||||
| `ramp` | **Deprecated**. Replaced by `on_ramp` and `off_ramp`. |
|
||||
| `on ramp` | take a ramp to enter a highway (direction given my `modifier`) |
|
||||
| `off ramp` | take a ramp to exit a highway (direction given my `modifier`) |
|
||||
| `fork` | take the left/right side at a fork depending on `modifier` |
|
||||
| `end of road` | road ends in a T intersection turn in direction of `modifier`|
|
||||
| `use lane` | going straight on a specific lane |
|
||||
| `continue` | Turn in direction of `modifier` to stay on the same road |
|
||||
| `roundabout` | traverse roundabout, has additional field `exit` with NR if the roundabout is left. `the modifier specifies the direction of entering the roundabout` |
|
||||
| `rotary` | a larger version of a roundabout, can offer `rotary_name` in addition to the `exit` parameter. |
|
||||
| `roundabout turn`| Describes a turn at a small roundabout that should be treated as normal turn. The `modifier` indicates the turn direciton. Example instruction: `At the roundabout turn left`. |
|
||||
| `notification` | not an actual turn but a change in the driving conditions. For example the travel mode. If the road takes a turn itself, the `modifier` describes the direction |
|
||||
|
||||
Please note that even though there are `new name` and `notification` instructions, the `mode` and `name` can change
|
||||
between all instructions. They only offer a fallback in case nothing else is to report.
|
||||
@@ -511,14 +512,14 @@ step.
|
||||
|
||||
| `modifier` | Description |
|
||||
|-------------------|-------------------------------------------|
|
||||
| uturn | indicates reversal of direction |
|
||||
| sharp right | a sharp right turn |
|
||||
| right | a normal turn to the right |
|
||||
| slight right | a slight turn to the right |
|
||||
| straight | no relevant change in direction |
|
||||
| slight left | a slight turn to the left |
|
||||
| left | a normal turn to the left |
|
||||
| sharp left | a sharp turn to the left |
|
||||
| `uturn` | indicates reversal of direction |
|
||||
| `sharp right` | a sharp right turn |
|
||||
| `right` | a normal turn to the right |
|
||||
| `slight right` | a slight turn to the right |
|
||||
| `straight` | no relevant change in direction |
|
||||
| `slight left` | a slight turn to the left |
|
||||
| `left` | a normal turn to the left |
|
||||
| `sharp left` | a sharp turn to the left |
|
||||
|
||||
The list of turns without a modifier is limited to: `depart/arrive`. If the source/target location is close enough to the `depart/arrive` location, no modifier will be given.
|
||||
|
||||
@@ -542,7 +543,7 @@ New properties (potentially depending on `type`) may be introduced in the future
|
||||
|
||||
### Lane
|
||||
|
||||
A lane give a representation of turn lane at the corresponding turn location.
|
||||
A `Lane` represents a turn lane at the corresponding turn location.
|
||||
|
||||
#### Properties
|
||||
|
||||
@@ -551,14 +552,14 @@ A lane give a representation of turn lane at the corresponding turn location.
|
||||
| `value` | Description |
|
||||
|------------------------|---------------------------------------------------------------------------------------------------------------------------|
|
||||
| `none` | No dedicated indication is shown. |
|
||||
| `uturn` | An indication signaling the possibility to reverse (i.e. fully bend arrow). |
|
||||
| `sharp right` | An indication indicating a sharp right turn (i.e. strongly bend arrow). |
|
||||
| `right` | An indication indicating a right turn (i.e. bend arrow). |
|
||||
| `sharp right` | An indication indicating a slight right turn (i.e. slightly bend arrow). |
|
||||
| `slight right` | An indication indicating a slight right turn (i.e. slightly bend arrow). |
|
||||
| `straight` | No dedicated indication is shown (i.e. straight arrow). |
|
||||
| `sharp left` | An indication indicating a sharp left turn (i.e. strongly bend arrow). |
|
||||
| `slight left` | An indication indicating a slight left turn (i.e. slightly bend arrow). |
|
||||
| `left` | An indication indicating a left turn (i.e. bend arrow). |
|
||||
| `sharp left` | An indication indicating a slight left turn (i.e. slightly bend arrow). |
|
||||
| `uturn` | An indication signaling the possibility to reverse (i.e. fully bend arrow). |
|
||||
| `sharp left` | An indication indicating a sharp left turn (i.e. strongly bend arrow). |
|
||||
|
||||
- `valid`: a boolean flag indicating whether the lane is a valid choice in the current maneuver
|
||||
|
||||
@@ -566,7 +567,7 @@ A lane give a representation of turn lane at the corresponding turn location.
|
||||
|
||||
```json
|
||||
{
|
||||
"indication": ["left", "straight"],
|
||||
"indications": ["left", "straight"],
|
||||
"valid": "false"
|
||||
}
|
||||
```
|
||||
|
||||
@@ -15,14 +15,14 @@ Feature: Turn Lane Guidance
|
||||
| | | y | | e | | |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward |
|
||||
| ab | through\|right&right&right |
|
||||
| bx | |
|
||||
| bc | left\|left&through |
|
||||
| cd | through\|right |
|
||||
| cy | |
|
||||
| dz | |
|
||||
| de | |
|
||||
| nodes | turn:lanes:forward |
|
||||
| ab | through\|right\|right\|right |
|
||||
| bx | |
|
||||
| bc | left\|left\|through |
|
||||
| cd | through\|right |
|
||||
| cy | |
|
||||
| dz | |
|
||||
| de | |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes | # |
|
||||
@@ -39,13 +39,13 @@ Feature: Turn Lane Guidance
|
||||
| e | | d | y |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | turn:lanes:backward | name |
|
||||
| ab | through\|right&right | | MySt |
|
||||
| bx | | | XSt |
|
||||
| bc | | left\|right | MySt |
|
||||
| cd | left\|right | through\|through | MySt |
|
||||
| de | | left\|left&through | MySt |
|
||||
| dy | | | YSt |
|
||||
| nodes | turn:lanes:forward | turn:lanes:backward | name |
|
||||
| ab | through\|right\|right | | MySt |
|
||||
| bx | | | XSt |
|
||||
| bc | | left\|right | MySt |
|
||||
| cd | left\|right | through\|through | MySt |
|
||||
| de | | left\|left\|through | MySt |
|
||||
| dy | | | YSt |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -62,13 +62,13 @@ Feature: Turn Lane Guidance
|
||||
| e | | d | y |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | turn:lanes:backward | name |
|
||||
| ab | through\|right&right | | AXSt |
|
||||
| bx | | | AXSt |
|
||||
| bc | | left\|right | BDSt |
|
||||
| cd | left\|right | through\|through | BDSt |
|
||||
| de | | left\|left&through | EYSt |
|
||||
| dy | | | EYSt |
|
||||
| nodes | turn:lanes:forward | turn:lanes:backward | name |
|
||||
| ab | through\|right\|right | | AXSt |
|
||||
| bx | | | AXSt |
|
||||
| bc | | left\|right | BDSt |
|
||||
| cd | left\|right | through\|through | BDSt |
|
||||
| de | | left\|left\|through | EYSt |
|
||||
| dy | | | EYSt |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -105,13 +105,13 @@ Feature: Turn Lane Guidance
|
||||
| | | | | | j |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | lanes | highway | oneway | name |
|
||||
| ab | none\|none&none&slight_right&slight_right | 5 | motorway | | abx |
|
||||
| bx | | 3 | motorway | | abx |
|
||||
| bc | | 2 | motorway_link | yes | bcd |
|
||||
| cd | slight_left\|slight_left;slight_right&slight_right | 3 | motorway_link | yes | bcd |
|
||||
| di | slight_left\|slight_right | 2 | motorway_link | yes | di |
|
||||
| dj | | 2 | motorway_link | yes | dj |
|
||||
| nodes | turn:lanes:forward | lanes | highway | oneway | name |
|
||||
| ab | none\|none\|none\|slight_right\|slight_right | 5 | motorway | | abx |
|
||||
| bx | | 3 | motorway | | abx |
|
||||
| bc | | 2 | motorway_link | yes | bcd |
|
||||
| cd | slight_left\|slight_left;slight_right\|slight_right | 3 | motorway_link | yes | bcd |
|
||||
| di | slight_left\|slight_right | 2 | motorway_link | yes | di |
|
||||
| dj | | 2 | motorway_link | yes | dj |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -150,14 +150,14 @@ Feature: Turn Lane Guidance
|
||||
| | | y | | e | | |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | name |
|
||||
| ab | through\|right&right&right | abx |
|
||||
| bx | | abx |
|
||||
| bc | left\|left&through | bcy |
|
||||
| cy | | bcy |
|
||||
| cd | through\|right | cdz |
|
||||
| dz | | cdz |
|
||||
| de | | de |
|
||||
| nodes | turn:lanes:forward | name |
|
||||
| ab | through\|right\|right\|right | abx |
|
||||
| bx | | abx |
|
||||
| bc | left\|left\|through | bcy |
|
||||
| cy | | bcy |
|
||||
| cd | through\|right | cdz |
|
||||
| dz | | cdz |
|
||||
| de | | de |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -173,14 +173,14 @@ Feature: Turn Lane Guidance
|
||||
| | | y | | e | | |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | name |
|
||||
| ab | through\|right | abx |
|
||||
| bx | | abx |
|
||||
| bc | left\|left&through | bcy |
|
||||
| cy | | bcy |
|
||||
| cd | through\|right&right&right | cdz |
|
||||
| dz | | cdz |
|
||||
| de | | de |
|
||||
| nodes | turn:lanes:forward | name |
|
||||
| ab | through\|right | abx |
|
||||
| bx | | abx |
|
||||
| bc | left\|left\|through | bcy |
|
||||
| cy | | bcy |
|
||||
| cd | through\|right\|right\|right | cdz |
|
||||
| dz | | cdz |
|
||||
| de | | de |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -196,14 +196,14 @@ Feature: Turn Lane Guidance
|
||||
| | | y | | e | | |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | name |
|
||||
| ab | through\|right&right&right | abx |
|
||||
| bx | | abx |
|
||||
| bc | left\|left&through | bcy |
|
||||
| cy | | bcy |
|
||||
| cd | through\|right&right&right | cdz |
|
||||
| dz | | cdz |
|
||||
| de | | de |
|
||||
| nodes | turn:lanes:forward | name |
|
||||
| ab | through\|right\|right\|right | abx |
|
||||
| bx | | abx |
|
||||
| bc | left\|left\|through | bcy |
|
||||
| cy | | bcy |
|
||||
| cd | through\|right\|right\|right | cdz |
|
||||
| dz | | cdz |
|
||||
| de | | de |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -219,14 +219,14 @@ Feature: Turn Lane Guidance
|
||||
| | | y | | e | | |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | name |
|
||||
| ab | through\|right | abx |
|
||||
| bx | | abx |
|
||||
| bc | left\|left&through | bcy |
|
||||
| cy | | bcy |
|
||||
| cd | through\|right | cdz |
|
||||
| dz | | cdz |
|
||||
| de | | de |
|
||||
| nodes | turn:lanes:forward | name |
|
||||
| ab | through\|right | abx |
|
||||
| bx | | abx |
|
||||
| bc | left\|left\|through | bcy |
|
||||
| cy | | bcy |
|
||||
| cd | through\|right | cdz |
|
||||
| dz | | cdz |
|
||||
| de | | de |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -244,21 +244,155 @@ Feature: Turn Lane Guidance
|
||||
| | | | | w | | |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | name |
|
||||
| ab | through\|right&right&right | abx |
|
||||
| bx | | abx |
|
||||
| bc | left\|left&through | bcy |
|
||||
| cy | | bcy |
|
||||
| cd | through\|right&right | cdz |
|
||||
| dz | | cdz |
|
||||
| de | left\|through | dew |
|
||||
| ew | | dew |
|
||||
| ef | | ef |
|
||||
| nodes | turn:lanes:forward | name |
|
||||
| ab | through\|right\|right\|right | abx |
|
||||
| bx | | abx |
|
||||
| bc | left\|left\|through | bcy |
|
||||
| cy | | bcy |
|
||||
| cd | through\|right\|right | cdz |
|
||||
| dz | | cdz |
|
||||
| de | left\|through | dew |
|
||||
| ew | | dew |
|
||||
| ef | | ef |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
| a,f | abx,bcy,cdz,dew,ef,ef | depart,turn right,turn left,turn right,turn left,arrive | ,straight:false right:false right:true right:false,left:false left:true straight:false,straight:false right:true right:false,left:true straight:false, |
|
||||
|
||||
@anticipate
|
||||
Scenario: Anticipate with lanes in roundabout: roundabouts as the unit of anticipation
|
||||
Given the node map
|
||||
| | | e | | |
|
||||
| a | b | | d | f |
|
||||
| | | c | | |
|
||||
| | | | | |
|
||||
| | | g | | |
|
||||
| k | h | | j | l |
|
||||
| | | i | | |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | highway | junction | # |
|
||||
| ab | slight_right\|slight_right\|slight_right | primary | | |
|
||||
| bc | slight_left\|slight_right\|slight_right | primary | roundabout | top |
|
||||
| cd | | primary | roundabout | top |
|
||||
| de | | primary | roundabout | top |
|
||||
| eb | | primary | roundabout | top |
|
||||
| df | | primary | | |
|
||||
| cg | slight_right\|slight_right | primary | | |
|
||||
| gh | slight_left\|slight_right | primary | roundabout | bot |
|
||||
| hi | | primary | roundabout | bot |
|
||||
| ij | slight_left\|slight_right | primary | roundabout | bot |
|
||||
| jg | | primary | roundabout | bot |
|
||||
| hk | | primary | | |
|
||||
| jl | | primary | | |
|
||||
|
||||
When I route I should get
|
||||
| # | waypoints | route | turns | lanes |
|
||||
| right-right | a,k | ab,cg,hk,hk | depart,roundabout-exit-1,roundabout-exit-1,arrive | ,slight right:false slight right:false slight right:true,slight right:false slight right:true, |
|
||||
| right-left | a,l | ab,cg,jl,jl | depart,roundabout-exit-1,roundabout-exit-2,arrive | ,slight right:false slight right:false slight right:true,slight right:false slight right:true, |
|
||||
| todo exits | a,f | ab,df,df | depart,roundabout-exit-2,arrive | ,slight right:false slight right:false slight right:true, |
|
||||
| todo exits | a,e | ab,bc,eb | depart,roundabout-exit-undefined,arrive | ,slight right:true slight right:true slight right:true, |
|
||||
|
||||
@anticipate @todo
|
||||
Scenario: Roundabout with lanes only tagged on exit
|
||||
Given the node map
|
||||
| | | e | | |
|
||||
| a | b | | d | f |
|
||||
| | | c | | |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | highway | junction |
|
||||
| ab | | primary | |
|
||||
| bc | | primary | roundabout |
|
||||
| cd | slight_left\|slight_left\|slight_right | primary | roundabout |
|
||||
| de | | primary | roundabout |
|
||||
| eb | | primary | roundabout |
|
||||
| df | | primary | |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
| a,f | ab,df,df | depart,roundabout-exit-1,use lane slight right,arrive | ,,slight left:false slight left:false slight right:true, |
|
||||
|
||||
@anticipate
|
||||
Scenario: Anticipate with lanes in roundabout where we stay on the roundabout for multiple exits
|
||||
Given the node map
|
||||
| | | a | | |
|
||||
| | | b | | |
|
||||
| | c | | g | h |
|
||||
| | | | | |
|
||||
| | d | | f | |
|
||||
| | | e | | |
|
||||
| x | | | | y |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | highway | junction |
|
||||
| ab | slight_right\|slight_right | primary | |
|
||||
| bc | | primary | roundabout |
|
||||
| cd | | primary | roundabout |
|
||||
| de | | primary | roundabout |
|
||||
| ef | | primary | roundabout |
|
||||
| fg | slight_right | primary | roundabout |
|
||||
| gb | | primary | roundabout |
|
||||
| gh | | primary | |
|
||||
| cx | | primary | |
|
||||
| dx | | primary | |
|
||||
| ey | | primary | |
|
||||
| fy | | primary | |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
| a,h | ab,gh,gh | depart,roundabout-exit-5,arrive | ,slight right:false slight right:true, |
|
||||
|
||||
@anticipate
|
||||
Scenario: Departing or arriving inside a roundabout does not yet anticipate lanes
|
||||
Given the node map
|
||||
| | | a | | |
|
||||
| x | b | | d | y |
|
||||
| | | c | | |
|
||||
|
||||
And the ways
|
||||
| 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 |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
| x,y | xb,dy,dy | depart,roundabout-exit-1,arrive | ,slight right:false slight right:true, |
|
||||
| x,c | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,slight right:true slight right:true, |
|
||||
| x,a | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,slight right:true slight right:true, |
|
||||
|
||||
@anticipate
|
||||
Scenario: Anticipate Lanes for turns before and / or after roundabout
|
||||
Given the node map
|
||||
| a | b | | | x |
|
||||
| | c | | | |
|
||||
| d | | f | g | z |
|
||||
| | e | | h | |
|
||||
| | | | | |
|
||||
| | y | | | |
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | highway | junction | name |
|
||||
| ab | through\|right\|right\|right\|right | primary | | abx |
|
||||
| bx | | primary | | abx |
|
||||
| bc | right\|right\|right\|right | primary | | bc |
|
||||
| cd | | primary | roundabout | cdefc |
|
||||
| de | slight_left\|slight_left&slight_left\|slight_right | primary | roundabout | cdefc |
|
||||
| ef | left\|slight_right\|slight_right | primary | roundabout | cdefc |
|
||||
| fc | | primary | roundabout | cdefc |
|
||||
| ey | | primary | | ey |
|
||||
| fg | through\|right | primary | | fg |
|
||||
| gz | | primary | | gz |
|
||||
| gh | | primary | | gh |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
| a,h | abx,bc,fg,gh,gh | depart,turn right,cdefc-exit-2,turn right,arrive | ,straight:false right:false right:false right:false right:true,right:false right:false right:false right:true,straight:false right:true, |
|
||||
|
||||
@anticipate @bug @todo
|
||||
Scenario: Tripple Right keeping Left
|
||||
Given the node map
|
||||
@@ -273,10 +407,10 @@ Feature: Turn Lane Guidance
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | highway | name |
|
||||
| abi | \|&right&right | primary | start |
|
||||
| bch | \|&right&right | primary | first |
|
||||
| cdj | \|&right&right | primary | second |
|
||||
| de | left\|right&right | secondary | third |
|
||||
| abi | \|\|right\|right | primary | start |
|
||||
| bch | \|\|right\|right | primary | first |
|
||||
| cdj | \|\|right\|right | primary | second |
|
||||
| de | left\|right\|right | secondary | third |
|
||||
| feg | | tertiary | fourth |
|
||||
|
||||
When I route I should get
|
||||
@@ -298,10 +432,10 @@ Feature: Turn Lane Guidance
|
||||
|
||||
And the ways
|
||||
| nodes | turn:lanes:forward | highway | name |
|
||||
| abi | left\|left&& | primary | start |
|
||||
| bch | left\|left&& | primary | first |
|
||||
| cdj | left\|left&& | primary | second |
|
||||
| de | left\|left&right | secondary | third |
|
||||
| abi | left\|left\|\| | primary | start |
|
||||
| bch | left\|left\|\| | primary | first |
|
||||
| cdj | left\|left\|\| | primary | second |
|
||||
| de | left\|left\|right | secondary | third |
|
||||
| feg | | tertiary | fourth |
|
||||
|
||||
When I route I should get
|
||||
|
||||
@@ -606,13 +606,13 @@ Feature: Collapse
|
||||
| restriction | bc | fdcg | c | no_right_turn |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns |
|
||||
| a,g | road,cross,cross | depart,turn left,arrive |
|
||||
| a,e | road,road,road | depart,continue slight right,arrive |
|
||||
# We should discuss whether the next item should be collapsed to depart,turn right,arrive.
|
||||
| a,f | road,road,cross,cross | depart,continue slight right,turn right,arrive |
|
||||
| waypoints | route | turns |
|
||||
| a,g | road,cross,cross | depart,turn left,arrive |
|
||||
| a,e | road,road,road | depart,continue slight right,arrive |
|
||||
# We should discuss whether the next item should be collapsed to depart,turn right,arrive.
|
||||
| a,f | road,road,cross,cross | depart,continue slight right,turn right,arrive |
|
||||
|
||||
Scenario: On-Off on Highway
|
||||
Scenario: On-Off on Highway
|
||||
Given the node map
|
||||
| f | | | |
|
||||
| a | b | c | d |
|
||||
|
||||
@@ -5,9 +5,7 @@ Feature: Turn Lane Guidance
|
||||
Given the profile "car"
|
||||
Given a grid size of 20 meters
|
||||
|
||||
#requires https://github.com/cucumber/cucumber-js/issues/417
|
||||
#Due to this, we use & as a pipe character. Switch them out for \| when 417 is fixed
|
||||
@bug @WORKAROUND-FIXME
|
||||
@bug
|
||||
Scenario: Basic Turn Lane 3-way Turn with empty lanes
|
||||
Given the node map
|
||||
| a | | b | | c |
|
||||
@@ -16,7 +14,7 @@ Feature: Turn Lane Guidance
|
||||
And the ways
|
||||
| nodes | turn:lanes | turn:lanes:forward | turn:lanes:backward | name |
|
||||
| ab | | through\|right | | in |
|
||||
| bc | | | left\|through&& | straight |
|
||||
| bc | | | left\|through\|\| | straight |
|
||||
| bd | | | left\|right | right |
|
||||
|
||||
When I route I should get
|
||||
@@ -89,7 +87,7 @@ Feature: Turn Lane Guidance
|
||||
|
||||
|
||||
#this next test requires decision on how to announce lanes for going straight if there is no turn
|
||||
@TODO @WORKAROUND-FIXME
|
||||
@TODO
|
||||
Scenario: Turn with Bus-Lane
|
||||
Given the node map
|
||||
| a | | b | | c |
|
||||
@@ -98,7 +96,7 @@ Feature: Turn Lane Guidance
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | lanes:psv:forward |
|
||||
| ab | road | through\|right& | 1 |
|
||||
| ab | road | through\|right\| | 1 |
|
||||
| bc | road | | |
|
||||
| bd | turn | | |
|
||||
|
||||
@@ -107,8 +105,26 @@ Feature: Turn Lane Guidance
|
||||
| a,d | road,turn,turn | depart,turn right,arrive | ,straight:false right:true, |
|
||||
| a,c | road,road,road | depart,use lane straight,arrive | ,straight:true right:false, |
|
||||
|
||||
@PROFILE @LANES
|
||||
Scenario: Turn with Bus-Lane but without lanes
|
||||
Given the node map
|
||||
| a | | b | | c |
|
||||
| | | | | |
|
||||
| | | d | | |
|
||||
|
||||
And the ways
|
||||
| nodes | name | lanes:psv |
|
||||
| ab | road | 1 |
|
||||
| bc | road | yes |
|
||||
| bd | turn | |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns |
|
||||
| a,d | road,turn,turn | depart,turn right,arrive |
|
||||
| a,c | road,road | depart,arrive |
|
||||
|
||||
#turn lanes are often drawn at the incoming road, even though the actual turn requires crossing the intersection first
|
||||
@todo @WORKAROUND-FIXME @bug
|
||||
@todo @bug
|
||||
Scenario: Turn Lanes at Segregated Road
|
||||
Given the node map
|
||||
| | | i | l | | |
|
||||
@@ -119,19 +135,19 @@ Feature: Turn Lane Guidance
|
||||
| | | j | k | | |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | oneway |
|
||||
| ab | road | left\|through&right | yes |
|
||||
| bc | road | left\|through | yes |
|
||||
| cd | road | | yes |
|
||||
| ef | road | \|through&through;right | yes |
|
||||
| fg | road | left;through\|through& | yes |
|
||||
| gh | road | | yes |
|
||||
| ig | cross | | yes |
|
||||
| gb | cross | left\|through | yes |
|
||||
| bj | cross | | yes |
|
||||
| kc | cross | left\|through;right | yes |
|
||||
| cf | cross | left\|through | yes |
|
||||
| fl | cross | | yes |
|
||||
| nodes | name | turn:lanes:forward | oneway |
|
||||
| ab | road | left\|through\|right | yes |
|
||||
| bc | road | left\|through | yes |
|
||||
| cd | road | | yes |
|
||||
| ef | road | \|through\|through;right | yes |
|
||||
| fg | road | left;through\|through\| | yes |
|
||||
| gh | road | | yes |
|
||||
| ig | cross | | yes |
|
||||
| gb | cross | left\|through | yes |
|
||||
| bj | cross | | yes |
|
||||
| kc | cross | left\|through;right | yes |
|
||||
| cf | cross | left\|through | yes |
|
||||
| fl | cross | | yes |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -163,19 +179,19 @@ Feature: Turn Lane Guidance
|
||||
| | | j | k | | |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | oneway |
|
||||
| ab | road | left\|through&right | yes |
|
||||
| bc | road | left\|through | yes |
|
||||
| cd | road | | yes |
|
||||
| ef | road | \|through&through;right | yes |
|
||||
| fg | road | left;through\|through& | yes |
|
||||
| gh | road | | yes |
|
||||
| ig | cross | | yes |
|
||||
| gb | cross | left\|through | yes |
|
||||
| bj | cross | | yes |
|
||||
| kc | cross | left\|through;right | yes |
|
||||
| cf | cross | left\|through | yes |
|
||||
| fl | cross | | yes |
|
||||
| nodes | name | turn:lanes:forward | oneway |
|
||||
| ab | road | left\|through\|right | yes |
|
||||
| bc | road | left\|through | yes |
|
||||
| cd | road | | yes |
|
||||
| ef | road | \|through\|through;right | yes |
|
||||
| fg | road | left;through\|through\| | yes |
|
||||
| gh | road | | yes |
|
||||
| ig | cross | | yes |
|
||||
| gb | cross | left\|through | yes |
|
||||
| bj | cross | | yes |
|
||||
| kc | cross | left\|through;right | yes |
|
||||
| cf | cross | left\|through | yes |
|
||||
| fl | cross | | yes |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -194,14 +210,14 @@ Feature: Turn Lane Guidance
|
||||
| | | j | k | | |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | oneway |
|
||||
| ab | road | left\|through&right | yes |
|
||||
| bc | road | | yes |
|
||||
| cd | road | | yes |
|
||||
| gb | cross | | yes |
|
||||
| bj | cross | | yes |
|
||||
| kc | cross | | yes |
|
||||
| cf | cross | | yes |
|
||||
| nodes | name | turn:lanes:forward | oneway |
|
||||
| ab | road | left\|through\|right | yes |
|
||||
| bc | road | | yes |
|
||||
| cd | road | | yes |
|
||||
| gb | cross | | yes |
|
||||
| bj | cross | | yes |
|
||||
| kc | cross | | yes |
|
||||
| cf | cross | | yes |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -311,13 +327,13 @@ Feature: Turn Lane Guidance
|
||||
| | | | f | | |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward |
|
||||
| ab | road | left\|through&right |
|
||||
| bc | road | |
|
||||
| cd | road | left\|through |
|
||||
| de | through | |
|
||||
| dg | left | |
|
||||
| cf | right | |
|
||||
| nodes | name | turn:lanes:forward |
|
||||
| ab | road | left\|through\|right |
|
||||
| bc | road | |
|
||||
| cd | road | left\|through |
|
||||
| de | through | |
|
||||
| dg | left | |
|
||||
| cf | right | |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -366,16 +382,16 @@ Feature: Turn Lane Guidance
|
||||
| g | traffic_signals |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | junction | oneway | highway |
|
||||
| abcdef | roundabout | | roundabout | yes | primary |
|
||||
| gha | roundabout | | roundabout | yes | primary |
|
||||
| fg | roundabout | slight_left\|slight_left;slight_right&slight_right&slight_right | roundabout | yes | primary |
|
||||
| aoib | top | | | yes | primary |
|
||||
| cjd | left | | | yes | primary |
|
||||
| ekf | bottom | | | yes | primary |
|
||||
| fng | bottom-right | | | yes | primary |
|
||||
| hma | top-right | | | yes | primary |
|
||||
| hl | top-right-out | | | yes | secondary |
|
||||
| nodes | name | turn:lanes:forward | junction | oneway | highway |
|
||||
| abcdef | roundabout | | roundabout | yes | primary |
|
||||
| gha | roundabout | | roundabout | yes | primary |
|
||||
| fg | roundabout | slight_left\|slight_left;slight_right\|slight_right\|slight_right | roundabout | yes | primary |
|
||||
| aoib | top | | | yes | primary |
|
||||
| cjd | left | | | yes | primary |
|
||||
| ekf | bottom | | | yes | primary |
|
||||
| fng | bottom-right | | | yes | primary |
|
||||
| hma | top-right | | | yes | primary |
|
||||
| hl | top-right-out | | | yes | secondary |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -393,12 +409,12 @@ Feature: Turn Lane Guidance
|
||||
| | | | f | |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | oneway | highway |
|
||||
| ab | road | left\|left&through&through | yes | primary |
|
||||
| bd | road | through\|through | yes | primary |
|
||||
| bc | road | left\|left | yes | primary |
|
||||
| de | road | | yes | primary |
|
||||
| fdcg | cross | | | secondary |
|
||||
| nodes | name | turn:lanes:forward | oneway | highway |
|
||||
| ab | road | left\|left\|through\|through | yes | primary |
|
||||
| bd | road | through\|through | yes | primary |
|
||||
| bc | road | left\|left | yes | primary |
|
||||
| de | road | | yes | primary |
|
||||
| fdcg | cross | | | secondary |
|
||||
|
||||
And the relations
|
||||
| type | way:from | way:to | node:via | restriction |
|
||||
@@ -422,8 +438,8 @@ Feature: Turn Lane Guidance
|
||||
| nodes | name | turn:lanes:forward | oneway | highway |
|
||||
| ab | road | | no | primary |
|
||||
| di | road | | yes | primary |
|
||||
| bc | road | \|through&right | yes | primary |
|
||||
| cd | road | \|through&right | yes | primary |
|
||||
| bc | road | \|through\|right | yes | primary |
|
||||
| cd | road | \|through\|right | yes | primary |
|
||||
| fc | road | | no | tertiary |
|
||||
| jefb | road | | yes | primary |
|
||||
| gdeh | cross | | no | primary |
|
||||
@@ -446,12 +462,12 @@ Feature: Turn Lane Guidance
|
||||
| | | | | | h | |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | oneway | highway |
|
||||
| abc | road | left\|left&left&through&through | yes | primary |
|
||||
| cde | road | | yes | primary |
|
||||
| hc | cross | | yes | secondary |
|
||||
| cg | straight | | no | tertiary |
|
||||
| cf | left | | yes | primary |
|
||||
| nodes | name | turn:lanes:forward | oneway | highway |
|
||||
| abc | road | left\|left\|left\|through\|through | yes | primary |
|
||||
| cde | road | | yes | primary |
|
||||
| hc | cross | | yes | secondary |
|
||||
| cg | straight | | no | tertiary |
|
||||
| cf | left | | yes | primary |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -471,15 +487,15 @@ Feature: Turn Lane Guidance
|
||||
| | | | | j | | |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | oneway | highway | junction |
|
||||
| efgha | round | | yes | primary | roundabout |
|
||||
| ab | round | | yes | primary | roundabout |
|
||||
| bc | round | slight_left\|slight_left&slight_right | yes | primary | roundabout |
|
||||
| cd | round | | yes | primary | roundabout |
|
||||
| de | round | slight_left\|slight_right | yes | primary | roundabout |
|
||||
| ib | left | slight_left\|slight_left&slight_right | yes | primary | |
|
||||
| cj | bottom | | yes | primary | |
|
||||
| ek | right | | yes | primary | |
|
||||
| nodes | name | turn:lanes:forward | oneway | highway | junction |
|
||||
| efgha | round | | yes | primary | roundabout |
|
||||
| ab | round | | yes | primary | roundabout |
|
||||
| bc | round | slight_left\|slight_left\|slight_right | yes | primary | roundabout |
|
||||
| cd | round | | yes | primary | roundabout |
|
||||
| de | round | slight_left\|slight_right | yes | primary | roundabout |
|
||||
| ib | left | slight_left\|slight_left\|slight_right | yes | primary | |
|
||||
| cj | bottom | | yes | primary | |
|
||||
| ek | right | | yes | primary | |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -496,10 +512,10 @@ Feature: Turn Lane Guidance
|
||||
| b | traffic_signals |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | highway |
|
||||
| abc | road | through\|through&through;slight_right&slight_right | primary |
|
||||
| cd | road | | primary |
|
||||
| ce | cross | | primary |
|
||||
| nodes | name | turn:lanes:forward | highway |
|
||||
| abc | road | through\|through\|through;slight_right\|slight_right | primary |
|
||||
| cd | road | | primary |
|
||||
| ce | cross | | primary |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -512,10 +528,10 @@ Feature: Turn Lane Guidance
|
||||
| | | | | | | e |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | highway |
|
||||
| abc | hwy | through\|through&through;slight_right&slight_right | motorway |
|
||||
| cd | hwy | | motorway |
|
||||
| ce | ramp | | motorway_link |
|
||||
| nodes | name | turn:lanes:forward | highway |
|
||||
| abc | hwy | through\|through\|through;slight_right\|slight_right | motorway |
|
||||
| cd | hwy | | motorway |
|
||||
| ce | ramp | | motorway_link |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -552,10 +568,10 @@ Feature: Turn Lane Guidance
|
||||
| | | | | | | | | | | d | |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | highway | oneway |
|
||||
| ab | hwy | through\|through&slight_right | motorway | yes |
|
||||
| bc | hwy | | motorway | yes |
|
||||
| bd | ramp | | motorway_link | yes |
|
||||
| nodes | name | turn:lanes:forward | highway | oneway |
|
||||
| ab | hwy | through\|through\|slight_right | motorway | yes |
|
||||
| bc | hwy | | motorway | yes |
|
||||
| bd | ramp | | motorway_link | yes |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -570,11 +586,11 @@ Feature: Turn Lane Guidance
|
||||
| a | | | | | b | | | | | | c |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | highway | oneway |
|
||||
| ab | road | reverse\|through&through | primary | yes |
|
||||
| bc | road | | primary | yes |
|
||||
| bdeg | road | | primary_link | yes |
|
||||
| fgh | road | | primary | yes |
|
||||
| nodes | name | turn:lanes:forward | highway | oneway |
|
||||
| ab | road | reverse\|through\|through | primary | yes |
|
||||
| bc | road | | primary | yes |
|
||||
| bdeg | road | | primary_link | yes |
|
||||
| fgh | road | | primary | yes |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -588,11 +604,11 @@ Feature: Turn Lane Guidance
|
||||
| a | | | | | b | | | | | | c |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | highway | oneway |
|
||||
| ab | road | reverse\|through&none | primary | yes |
|
||||
| bc | road | | primary | yes |
|
||||
| bdeg | road | | primary_link | yes |
|
||||
| fgh | road | | primary | yes |
|
||||
| nodes | name | turn:lanes:forward | highway | oneway |
|
||||
| ab | road | reverse\|through\|none | primary | yes |
|
||||
| bc | road | | primary | yes |
|
||||
| bdeg | road | | primary_link | yes |
|
||||
| fgh | road | | primary | yes |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
@@ -607,12 +623,12 @@ Feature: Turn Lane Guidance
|
||||
| | | i | | | | | | | | | |
|
||||
|
||||
And the ways
|
||||
| nodes | name | turn:lanes:forward | highway | oneway |
|
||||
| ajb | road | reverse\|through&none | primary | yes |
|
||||
| bc | road | | primary | yes |
|
||||
| bdeg | road | | primary_link | yes |
|
||||
| fgh | road | | primary | yes |
|
||||
| ji | park | | service | no |
|
||||
| nodes | name | turn:lanes:forward | highway | oneway |
|
||||
| ajb | road | reverse\|through\|none | primary | yes |
|
||||
| bc | road | | primary | yes |
|
||||
| bdeg | road | | primary_link | yes |
|
||||
| fgh | road | | primary | yes |
|
||||
| ji | park | | service | no |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | route | turns | lanes |
|
||||
|
||||
@@ -853,3 +853,29 @@ Feature: Simple Turns
|
||||
| a,c | depart,arrive | road,road |
|
||||
| d,a | depart,turn left,arrive | in,road,road |
|
||||
| d,c | depart,new name straight,arrive | in,road,road |
|
||||
|
||||
Scenario: Channing Street
|
||||
Given the node map
|
||||
| | | g | f | |
|
||||
| | | | | |
|
||||
| d | | c | b | a |
|
||||
| | | | | |
|
||||
| | | | | |
|
||||
| | | h | e | |
|
||||
|
||||
And the nodes
|
||||
| node | highway |
|
||||
| c | traffic_signals |
|
||||
| b | traffic_signals |
|
||||
|
||||
And the ways
|
||||
| nodes | name | highway | oneway |
|
||||
| ab | Channing Street Northeast | residential | no |
|
||||
| bcd | Channing Street Northwest | residential | yes |
|
||||
| ebf | North Capitol Street Northeast | primary | yes |
|
||||
| gch | North Capitol Street Northeast | primary | yes |
|
||||
|
||||
When I route I should get
|
||||
| waypoints | turns | route |
|
||||
| a,d | depart,arrive | Channing Street Northeast,Channing Street Northwest |
|
||||
| a,h | depart,turn left,arrive | Channing Street Northeast,North Capitol Street Northeast,North Capitol Street Northeast |
|
||||
|
||||
@@ -15,16 +15,4 @@ module.exports = function () {
|
||||
this.setOrigin(this.DEFAULT_ORIGIN);
|
||||
callback();
|
||||
});
|
||||
|
||||
this.Before('@ignore-platform-windows', () => {
|
||||
this.skipThisScenario();
|
||||
});
|
||||
|
||||
this.Before('@ignore-platform-unix', () => {
|
||||
this.skipThisScenario();
|
||||
});
|
||||
|
||||
this.Before('@ignore-platform-mac', () => {
|
||||
this.skipThisScenario();
|
||||
});
|
||||
};
|
||||
|
||||
@@ -33,9 +33,4 @@ module.exports = function () {
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
this.Around('@stress', (scenario, callback) => {
|
||||
// TODO implement stress timeout? Around support is being dropped in cucumber-js anyway
|
||||
callback();
|
||||
});
|
||||
};
|
||||
|
||||
@@ -233,7 +233,7 @@ Feature: Basic Routing
|
||||
| d | a | abcd,abcd |
|
||||
| a | m | aeim,aeim |
|
||||
| m | a | aeim,aeim |
|
||||
|
||||
|
||||
Scenario: Testbot - Triangle challenge
|
||||
Given the node map
|
||||
| | | | d |
|
||||
@@ -251,3 +251,39 @@ Feature: Basic Routing
|
||||
| from | to | route |
|
||||
| d | c | de,ce,ce |
|
||||
| e | d | de,de |
|
||||
|
||||
Scenario: Ambiguous edge weights - Use minimal edge weight
|
||||
Given the node map
|
||||
| a | b |
|
||||
|
||||
And the ways
|
||||
| nodes | highway | name |
|
||||
| ab | tertiary | |
|
||||
| ab | primary | |
|
||||
| ab | secondary | |
|
||||
|
||||
When I route I should get
|
||||
| from | to | route | time |
|
||||
| a | b | , | 10s |
|
||||
| b | a | , | 10s |
|
||||
|
||||
Scenario: Ambiguous edge names - Use lexicographically smallest name
|
||||
Given the node map
|
||||
| a | b | c |
|
||||
|
||||
And the ways
|
||||
| nodes | highway | name |
|
||||
| ab | primary | |
|
||||
| ab | primary | Αβγ |
|
||||
| ab | primary | |
|
||||
| ab | primary | Abc |
|
||||
| ab | primary | |
|
||||
| ab | primary | Абв |
|
||||
| bc | primary | Ηθι |
|
||||
| bc | primary | Δεζ |
|
||||
| bc | primary | Где |
|
||||
|
||||
When I route I should get
|
||||
| from | to | route |
|
||||
| a | c | Abc,Δεζ,Δεζ |
|
||||
| c | a | Δεζ,Abc,Abc |
|
||||
|
||||
@@ -29,7 +29,7 @@ Feature: Basic Routing
|
||||
Scenario: Check handling empty values
|
||||
Given the node map
|
||||
| a | b | | c | | d | f |
|
||||
| | | | | | e |
|
||||
| | | | | | e | |
|
||||
|
||||
And the ways
|
||||
| nodes | name |
|
||||
|
||||
@@ -2,9 +2,13 @@
|
||||
#define OSRM_ENGINE_GUIDANCE_TOOLKIT_HPP_
|
||||
|
||||
#include "extractor/guidance/turn_instruction.hpp"
|
||||
#include "engine/guidance/route_step.hpp"
|
||||
#include "util/bearing.hpp"
|
||||
#include "util/guidance/toolkit.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <iterator>
|
||||
#include <utility>
|
||||
|
||||
namespace osrm
|
||||
{
|
||||
@@ -13,6 +17,10 @@ namespace engine
|
||||
namespace guidance
|
||||
{
|
||||
|
||||
using util::guidance::entersRoundabout;
|
||||
using util::guidance::leavesRoundabout;
|
||||
using util::guidance::staysOnRoundabout;
|
||||
|
||||
// Silent Turn Instructions are not to be mentioned to the outside world but
|
||||
inline bool isSilent(const extractor::guidance::TurnInstruction instruction)
|
||||
{
|
||||
@@ -21,34 +29,6 @@ inline bool isSilent(const extractor::guidance::TurnInstruction instruction)
|
||||
instruction.type == extractor::guidance::TurnType::StayOnRoundabout;
|
||||
}
|
||||
|
||||
inline bool entersRoundabout(const extractor::guidance::TurnInstruction instruction)
|
||||
{
|
||||
return (instruction.type == extractor::guidance::TurnType::EnterRoundabout ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRotary ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRoundaboutIntersection ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRoundaboutAtExit ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRotaryAtExit ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRoundaboutIntersectionAtExit ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRoundabout ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRotary ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRotary);
|
||||
}
|
||||
|
||||
inline bool leavesRoundabout(const extractor::guidance::TurnInstruction instruction)
|
||||
{
|
||||
return (instruction.type == extractor::guidance::TurnType::ExitRoundabout ||
|
||||
instruction.type == extractor::guidance::TurnType::ExitRotary ||
|
||||
instruction.type == extractor::guidance::TurnType::ExitRoundaboutIntersection ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRoundabout ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRotary ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRoundaboutIntersection);
|
||||
}
|
||||
|
||||
inline bool staysOnRoundabout(const extractor::guidance::TurnInstruction instruction)
|
||||
{
|
||||
return instruction.type == extractor::guidance::TurnType::StayOnRoundabout;
|
||||
}
|
||||
|
||||
inline extractor::guidance::DirectionModifier::Enum angleToDirectionModifier(const double bearing)
|
||||
{
|
||||
if (bearing < 135)
|
||||
@@ -63,6 +43,38 @@ inline extractor::guidance::DirectionModifier::Enum angleToDirectionModifier(con
|
||||
return extractor::guidance::DirectionModifier::Left;
|
||||
}
|
||||
|
||||
// Runs fn on RouteStep sub-ranges determined to be roundabouts.
|
||||
// The function fn is getting called with a roundabout range as in: [enter, .., leave].
|
||||
//
|
||||
// The following situations are taken care for (i.e. we discard them):
|
||||
// - partial roundabout: enter without exit or exit without enter
|
||||
// - data issues: no roundabout, exit before enter
|
||||
template <typename Iter, typename Fn> inline Fn forEachRoundabout(Iter first, Iter last, Fn fn)
|
||||
{
|
||||
while (first != last)
|
||||
{
|
||||
const auto enter = std::find_if(first, last, [](const RouteStep &step) {
|
||||
return entersRoundabout(step.maneuver.instruction);
|
||||
});
|
||||
|
||||
// enter has to come before leave, otherwise: faulty data / partial roundabout, skip those
|
||||
const auto leave = std::find_if(enter, last, [](const RouteStep &step) {
|
||||
return leavesRoundabout(step.maneuver.instruction);
|
||||
});
|
||||
|
||||
// No roundabouts, or partial one (like start / end inside a roundabout)
|
||||
if (enter == last || leave == last)
|
||||
break;
|
||||
|
||||
(void)fn(std::make_pair(enter, leave));
|
||||
|
||||
// Skip to first step after the currently handled enter / leave pair
|
||||
first = std::next(leave);
|
||||
}
|
||||
|
||||
return fn;
|
||||
}
|
||||
|
||||
} // namespace guidance
|
||||
} // namespace engine
|
||||
} // namespace osrm
|
||||
|
||||
@@ -46,28 +46,34 @@ namespace extractor
|
||||
namespace lookup
|
||||
{
|
||||
// Set to 1 byte alignment
|
||||
#pragma pack(push, 1)
|
||||
struct SegmentHeaderBlock
|
||||
{
|
||||
std::uint32_t num_osm_nodes;
|
||||
OSMNodeID previous_osm_node_id;
|
||||
} __attribute ((packed));
|
||||
};
|
||||
#pragma pack(pop)
|
||||
static_assert(sizeof(SegmentHeaderBlock) == 12, "SegmentHeaderBlock is not packed correctly");
|
||||
|
||||
#pragma pack(push, 1)
|
||||
struct SegmentBlock
|
||||
{
|
||||
OSMNodeID this_osm_node_id;
|
||||
double segment_length;
|
||||
std::int32_t segment_weight;
|
||||
} __attribute ((packed));
|
||||
};
|
||||
#pragma pack(pop)
|
||||
static_assert(sizeof(SegmentBlock) == 20, "SegmentBlock is not packed correctly");
|
||||
|
||||
#pragma pack(push, 1)
|
||||
struct PenaltyBlock
|
||||
{
|
||||
std::uint32_t fixed_penalty;
|
||||
OSMNodeID from_id;
|
||||
OSMNodeID via_id;
|
||||
OSMNodeID to_id;
|
||||
} __attribute ((packed));
|
||||
};
|
||||
#pragma pack(pop)
|
||||
static_assert(sizeof(PenaltyBlock) == 28, "PenaltyBlock is not packed correctly");
|
||||
}
|
||||
|
||||
|
||||
@@ -8,9 +8,9 @@
|
||||
#include "extractor/restriction.hpp"
|
||||
#include "extractor/scripting_environment.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
#include <stxxl/vector>
|
||||
#include <unordered_map>
|
||||
#include <cstdint>
|
||||
|
||||
namespace osrm
|
||||
{
|
||||
@@ -39,12 +39,11 @@ class ExtractionContainers
|
||||
void WriteNodes(std::ofstream &file_out_stream) const;
|
||||
void WriteRestrictions(const std::string &restrictions_file_name) const;
|
||||
void WriteEdges(std::ofstream &file_out_stream) const;
|
||||
void WriteCharData(const std::string &file_name,
|
||||
const stxxl::vector<unsigned> &offests,
|
||||
const stxxl::vector<char> &char_data) const;
|
||||
void WriteTurnLaneMasks(const std::string &file_name,
|
||||
const stxxl::vector<std::uint32_t> &turn_lane_offsets,
|
||||
const stxxl::vector<guidance::TurnLaneType::Mask> &turn_lane_masks) const;
|
||||
void WriteCharData(const std::string &file_name);
|
||||
void
|
||||
WriteTurnLaneMasks(const std::string &file_name,
|
||||
const stxxl::vector<std::uint32_t> &turn_lane_offsets,
|
||||
const stxxl::vector<guidance::TurnLaneType::Mask> &turn_lane_masks) const;
|
||||
|
||||
public:
|
||||
using STXXLNodeIDVector = stxxl::vector<OSMNodeID>;
|
||||
@@ -52,12 +51,14 @@ class ExtractionContainers
|
||||
using STXXLEdgeVector = stxxl::vector<InternalExtractorEdge>;
|
||||
using STXXLRestrictionsVector = stxxl::vector<InputRestrictionContainer>;
|
||||
using STXXLWayIDStartEndVector = stxxl::vector<FirstAndLastSegmentOfWay>;
|
||||
using STXXLNameCharData = stxxl::vector<unsigned char>;
|
||||
using STXXLNameOffsets = stxxl::vector<unsigned>;
|
||||
|
||||
STXXLNodeIDVector used_node_id_list;
|
||||
STXXLNodeVector all_nodes_list;
|
||||
STXXLEdgeVector all_edges_list;
|
||||
stxxl::vector<char> name_char_data;
|
||||
stxxl::vector<unsigned> name_lengths;
|
||||
STXXLNameCharData name_char_data;
|
||||
STXXLNameOffsets name_offsets;
|
||||
// an adjacency array containing all turn lane masks
|
||||
stxxl::vector<std::uint32_t> turn_lane_offsets;
|
||||
stxxl::vector<guidance::TurnLaneType::Mask> turn_lane_masks;
|
||||
|
||||
@@ -40,6 +40,8 @@ using util::guidance::LaneTupelIdPair;
|
||||
using LaneDataIdMap = std::unordered_map<LaneTupelIdPair, LaneDataID, boost::hash<LaneTupelIdPair>>;
|
||||
|
||||
using util::guidance::angularDeviation;
|
||||
using util::guidance::entersRoundabout;
|
||||
using util::guidance::leavesRoundabout;
|
||||
|
||||
namespace detail
|
||||
{
|
||||
@@ -531,29 +533,6 @@ trimLaneString(std::string lane_string, std::int32_t count_left, std::int32_t co
|
||||
return lane_string;
|
||||
}
|
||||
|
||||
inline bool entersRoundabout(const extractor::guidance::TurnInstruction instruction)
|
||||
{
|
||||
return (instruction.type == extractor::guidance::TurnType::EnterRoundabout ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRotary ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRoundaboutIntersection ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRoundaboutAtExit ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRotaryAtExit ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRoundaboutIntersectionAtExit ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRoundabout ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRotary ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRotary);
|
||||
}
|
||||
|
||||
inline bool leavesRoundabout(const extractor::guidance::TurnInstruction instruction)
|
||||
{
|
||||
return (instruction.type == extractor::guidance::TurnType::ExitRoundabout ||
|
||||
instruction.type == extractor::guidance::TurnType::ExitRotary ||
|
||||
instruction.type == extractor::guidance::TurnType::ExitRoundaboutIntersection ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRoundabout ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRotary ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRoundaboutIntersection);
|
||||
}
|
||||
|
||||
} // namespace guidance
|
||||
} // namespace extractor
|
||||
} // namespace osrm
|
||||
|
||||
@@ -142,43 +142,6 @@ struct InternalExtractorEdge
|
||||
}
|
||||
};
|
||||
|
||||
struct CmpEdgeByInternalStartThenInternalTargetID
|
||||
{
|
||||
using value_type = InternalExtractorEdge;
|
||||
bool operator()(const InternalExtractorEdge &lhs, const InternalExtractorEdge &rhs) const
|
||||
{
|
||||
return (lhs.result.source < rhs.result.source) ||
|
||||
((lhs.result.source == rhs.result.source) &&
|
||||
(lhs.result.target < rhs.result.target));
|
||||
}
|
||||
|
||||
value_type max_value() { return InternalExtractorEdge::max_internal_value(); }
|
||||
value_type min_value() { return InternalExtractorEdge::min_internal_value(); }
|
||||
};
|
||||
|
||||
struct CmpEdgeByOSMStartID
|
||||
{
|
||||
using value_type = InternalExtractorEdge;
|
||||
bool operator()(const InternalExtractorEdge &lhs, const InternalExtractorEdge &rhs) const
|
||||
{
|
||||
return lhs.result.osm_source_id < rhs.result.osm_source_id;
|
||||
}
|
||||
|
||||
value_type max_value() { return InternalExtractorEdge::max_osm_value(); }
|
||||
value_type min_value() { return InternalExtractorEdge::min_osm_value(); }
|
||||
};
|
||||
|
||||
struct CmpEdgeByOSMTargetID
|
||||
{
|
||||
using value_type = InternalExtractorEdge;
|
||||
bool operator()(const InternalExtractorEdge &lhs, const InternalExtractorEdge &rhs) const
|
||||
{
|
||||
return lhs.result.osm_target_id < rhs.result.osm_target_id;
|
||||
}
|
||||
|
||||
value_type max_value() { return InternalExtractorEdge::max_osm_value(); }
|
||||
value_type min_value() { return InternalExtractorEdge::min_osm_value(); }
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -21,10 +21,13 @@ inline void print(const engine::guidance::RouteStep &step)
|
||||
{
|
||||
std::cout << static_cast<int>(step.maneuver.instruction.type) << " "
|
||||
<< static_cast<int>(step.maneuver.instruction.direction_modifier) << " "
|
||||
<< static_cast<int>(step.maneuver.waypoint_type) << " Duration: " << step.duration
|
||||
<< " Distance: " << step.distance << " Geometry: " << step.geometry_begin << " "
|
||||
<< step.geometry_end << " exit: " << step.maneuver.exit
|
||||
<< " Intersections: " << step.intersections.size() << " [";
|
||||
<< static_cast<int>(step.maneuver.waypoint_type) << " "
|
||||
<< " Lanes: (" << static_cast<int>(step.maneuver.lanes.lanes_in_turn) << ", "
|
||||
<< static_cast<int>(step.maneuver.lanes.first_lane_from_the_right) << ")"
|
||||
<< " Duration: " << step.duration << " Distance: " << step.distance
|
||||
<< " Geometry: " << step.geometry_begin << " " << step.geometry_end
|
||||
<< " exit: " << step.maneuver.exit << " Intersections: " << step.intersections.size()
|
||||
<< " [";
|
||||
|
||||
for (const auto &intersection : step.intersections)
|
||||
{
|
||||
|
||||
@@ -101,6 +101,34 @@ inline bool isRightTurn(const extractor::guidance::TurnInstruction instruction)
|
||||
}
|
||||
}
|
||||
|
||||
inline bool entersRoundabout(const extractor::guidance::TurnInstruction instruction)
|
||||
{
|
||||
return (instruction.type == extractor::guidance::TurnType::EnterRoundabout ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRotary ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRoundaboutIntersection ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRoundaboutAtExit ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRotaryAtExit ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterRoundaboutIntersectionAtExit ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRoundabout ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRotary ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRotary);
|
||||
}
|
||||
|
||||
inline bool leavesRoundabout(const extractor::guidance::TurnInstruction instruction)
|
||||
{
|
||||
return (instruction.type == extractor::guidance::TurnType::ExitRoundabout ||
|
||||
instruction.type == extractor::guidance::TurnType::ExitRotary ||
|
||||
instruction.type == extractor::guidance::TurnType::ExitRoundaboutIntersection ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRoundabout ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRotary ||
|
||||
instruction.type == extractor::guidance::TurnType::EnterAndExitRoundaboutIntersection);
|
||||
}
|
||||
|
||||
inline bool staysOnRoundabout(const extractor::guidance::TurnInstruction instruction)
|
||||
{
|
||||
return instruction.type == extractor::guidance::TurnType::StayOnRoundabout;
|
||||
}
|
||||
|
||||
} // namespace guidance
|
||||
} // namespace util
|
||||
} // namespace osrm
|
||||
|
||||
+4
-4
@@ -4,13 +4,13 @@
|
||||
"private": true,
|
||||
"description": "The Open Source Routing Machine is a high performance routing engine written in C++11 designed to run on OpenStreetMap data.",
|
||||
"dependencies": {
|
||||
"cucumber": "^0.9.4",
|
||||
"chalk": "^1.1.3",
|
||||
"cucumber": "^1.2.1",
|
||||
"d3-queue": "^2.0.3",
|
||||
"node-timeout": "0.0.4",
|
||||
"polyline": "^0.2.0",
|
||||
"request": "^2.69.0",
|
||||
"xmlbuilder": "^4.2.1",
|
||||
"chalk": "^1.1.3",
|
||||
"polyline": "^0.2.0"
|
||||
"xmlbuilder": "^4.2.1"
|
||||
},
|
||||
"bin": {
|
||||
"cucumber": "./node_modules/cucumber/bin/cucumber.js"
|
||||
|
||||
+13
-7
@@ -189,7 +189,7 @@ local function getPSVCounts(way)
|
||||
if( psv_backward and psv_backward ~= "" ) then
|
||||
bw = tonumber(psv_backward);
|
||||
if( bw == nil ) then
|
||||
fw = 0
|
||||
bw = 0
|
||||
end
|
||||
end
|
||||
return fw, bw
|
||||
@@ -206,10 +206,16 @@ local function getTurnLanes(way)
|
||||
local turn_lanes_bw = way:get_value_by_key("turn:lanes:backward")
|
||||
|
||||
if( fw_psv ~= 0 or bw_psv ~= 0 ) then
|
||||
turn_lanes = trimLaneString(turn_lanes, bw_psv, fw_psv )
|
||||
turn_lanes_fw = trimLaneString(turn_lanes_fw, bw_psv, fw_psv )
|
||||
if turn_lanes and turn_lanes ~= "" then
|
||||
turn_lanes = trimLaneString(turn_lanes, bw_psv, fw_psv )
|
||||
end
|
||||
if turn_lanes_fw and turn_lanes_fw ~= "" then
|
||||
turn_lanes_fw = trimLaneString(turn_lanes_fw, bw_psv, fw_psv )
|
||||
end
|
||||
--backwards turn lanes need to treat bw_psv as fw_psv and vice versa
|
||||
turn_lanes_bw = trimLaneString(turn_lanes_bw, fw_psv, bw_psv )
|
||||
if turn_lanes_bw and turn_lanes_bw ~= "" then
|
||||
turn_lanes_bw = trimLaneString(turn_lanes_bw, fw_psv, bw_psv )
|
||||
end
|
||||
end
|
||||
|
||||
return turn_lanes, turn_lanes_fw, turn_lanes_bw
|
||||
@@ -427,15 +433,15 @@ function way_function (way, result)
|
||||
local turn_lanes_backward = ""
|
||||
|
||||
turn_lanes, turn_lanes_forward, turn_lanes_backward = getTurnLanes(way)
|
||||
if( turn_lanes ~= "" ) then
|
||||
if turn_lanes and turn_lanes ~= "" then
|
||||
result.turn_lanes_forward = turn_lanes;
|
||||
result.turn_lanes_backward = turn_lanes;
|
||||
else
|
||||
if( turn_lanes_forward ~= "" ) then
|
||||
if turn_lanes_forward and turn_lanes_forward ~= "" then
|
||||
result.turn_lanes_forward = turn_lanes_forward;
|
||||
end
|
||||
|
||||
if( turn_lanes_backward ~= "" ) then
|
||||
if turn_lanes_backward and turn_lanes_backward ~= "" then
|
||||
result.turn_lanes_backward = turn_lanes_backward;
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
#include "extractor/guidance/turn_instruction.hpp"
|
||||
#include "engine/guidance/post_processing.hpp"
|
||||
#include "extractor/guidance/turn_instruction.hpp"
|
||||
|
||||
#include "engine/guidance/assemble_steps.hpp"
|
||||
#include "engine/guidance/lane_processing.hpp"
|
||||
#include "engine/guidance/toolkit.hpp"
|
||||
|
||||
#include "util/guidance/toolkit.hpp"
|
||||
@@ -385,7 +386,9 @@ void collapseTurnAt(std::vector<RouteStep> &steps,
|
||||
{
|
||||
BOOST_ASSERT(!one_back_step.intersections.empty());
|
||||
if (TurnType::Continue == current_step.maneuver.instruction.type ||
|
||||
TurnType::Suppressed == current_step.maneuver.instruction.type)
|
||||
(TurnType::Suppressed == current_step.maneuver.instruction.type &&
|
||||
current_step.maneuver.instruction.direction_modifier !=
|
||||
DirectionModifier::Straight))
|
||||
steps[step_index].maneuver.instruction.type = TurnType::Turn;
|
||||
else if (TurnType::Merge == current_step.maneuver.instruction.type)
|
||||
{
|
||||
@@ -399,6 +402,7 @@ void collapseTurnAt(std::vector<RouteStep> &steps,
|
||||
DirectionModifier::Straight &&
|
||||
one_back_step.intersections.front().bearings.size() > 2)
|
||||
steps[step_index].maneuver.instruction.type = TurnType::Turn;
|
||||
|
||||
steps[two_back_index] = elongate(std::move(steps[two_back_index]), one_back_step);
|
||||
// If the previous instruction asked to continue, the name change will have to
|
||||
// be changed into a turn
|
||||
@@ -416,9 +420,7 @@ void collapseTurnAt(std::vector<RouteStep> &steps,
|
||||
if ((TurnType::Continue == one_back_step.maneuver.instruction.type ||
|
||||
TurnType::Suppressed == one_back_step.maneuver.instruction.type) &&
|
||||
current_step.name_id != steps[two_back_index].name_id)
|
||||
{
|
||||
steps[one_back_index].maneuver.instruction.type = TurnType::Turn;
|
||||
}
|
||||
else if (TurnType::Turn == one_back_step.maneuver.instruction.type &&
|
||||
current_step.name_id == steps[two_back_index].name_id)
|
||||
{
|
||||
@@ -497,11 +499,49 @@ void collapseTurnAt(std::vector<RouteStep> &steps,
|
||||
}
|
||||
}
|
||||
|
||||
// Works on steps including silent and invalid instructions in order to do lane anticipation for
|
||||
// roundabouts which later on get collapsed into a single multi-hop instruction.
|
||||
std::vector<RouteStep> anticipateLaneChangeForRoundabouts(std::vector<RouteStep> steps)
|
||||
{
|
||||
using namespace util::guidance;
|
||||
|
||||
using StepIter = decltype(steps)::iterator;
|
||||
using StepIterRange = std::pair<StepIter, StepIter>;
|
||||
|
||||
const auto anticipate_lanes_in_roundabout = [&](StepIterRange roundabout) {
|
||||
// We do lane anticipation on the roundabout's enter and leave step only.
|
||||
// TODO: This means, lanes _inside_ the roundabout are ignored at the moment.
|
||||
|
||||
auto enter = *roundabout.first;
|
||||
const auto leave = *roundabout.second;
|
||||
|
||||
// Although the enter instruction may be a left/right turn, for right-sided driving the
|
||||
// roundabout is counter-clockwise and therefore we need to always set it to a left turn.
|
||||
// FIXME: assumes right-side driving (counter-clockwise roundabout flow)
|
||||
const auto enter_direction = enter.maneuver.instruction.direction_modifier;
|
||||
|
||||
if (util::guidance::isRightTurn(enter.maneuver.instruction))
|
||||
enter.maneuver.instruction.direction_modifier =
|
||||
mirrorDirectionModifier(enter_direction);
|
||||
|
||||
auto enterAndLeave = anticipateLaneChange({enter, leave});
|
||||
|
||||
// Undo flipping direction on a right turn in a right-sided counter-clockwise roundabout.
|
||||
// FIXME: assumes right-side driving (counter-clockwise roundabout flow)
|
||||
enterAndLeave[0].maneuver.instruction.direction_modifier = enter_direction;
|
||||
|
||||
std::swap(*roundabout.first, enterAndLeave[0]);
|
||||
std::swap(*roundabout.second, enterAndLeave[1]);
|
||||
};
|
||||
|
||||
forEachRoundabout(begin(steps), end(steps), anticipate_lanes_in_roundabout);
|
||||
|
||||
return steps;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
// Post processing can invalidate some instructions. For example StayOnRoundabout
|
||||
// is turned into exit counts. These instructions are removed by the following function
|
||||
|
||||
std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
|
||||
{
|
||||
// finally clean up the post-processed instructions.
|
||||
@@ -517,6 +557,9 @@ std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
|
||||
|
||||
boost::remove_erase_if(steps, not_is_valid);
|
||||
|
||||
// the steps should still include depart and arrive at least
|
||||
BOOST_ASSERT(steps.size() >= 2);
|
||||
|
||||
BOOST_ASSERT(steps.front().intersections.size() >= 1);
|
||||
BOOST_ASSERT(steps.front().intersections.front().bearings.size() == 1);
|
||||
BOOST_ASSERT(steps.front().intersections.front().entry.size() == 1);
|
||||
@@ -543,6 +586,11 @@ std::vector<RouteStep> postProcess(std::vector<RouteStep> steps)
|
||||
if (steps.size() == 2)
|
||||
return steps;
|
||||
|
||||
// Before we invalidate and remove silent instructions, we handle roundabouts (before they're
|
||||
// getting collapsed into a single multi-hop instruction) by back-propagating exit lane
|
||||
// constraints already to a roundabout's enter instruction.
|
||||
steps = anticipateLaneChangeForRoundabouts(std::move(steps));
|
||||
|
||||
// Count Street Exits forward
|
||||
bool on_roundabout = false;
|
||||
bool has_entered_roundabout = false;
|
||||
@@ -550,7 +598,7 @@ std::vector<RouteStep> postProcess(std::vector<RouteStep> steps)
|
||||
// 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 lag.
|
||||
// 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)
|
||||
{
|
||||
auto &step = steps[step_index];
|
||||
|
||||
@@ -26,6 +26,8 @@
|
||||
|
||||
namespace
|
||||
{
|
||||
namespace oe = osrm::extractor;
|
||||
|
||||
// Needed for STXXL comparison - STXXL requires max_value(), min_value(), so we can not use
|
||||
// std::less<OSMNodeId>{}. Anonymous namespace to keep translation unit local.
|
||||
struct OSMNodeIDSTXXLLess
|
||||
@@ -35,6 +37,69 @@ struct OSMNodeIDSTXXLLess
|
||||
value_type max_value() { return MAX_OSM_NODEID; }
|
||||
value_type min_value() { return MIN_OSM_NODEID; }
|
||||
};
|
||||
|
||||
struct CmpEdgeByOSMStartID
|
||||
{
|
||||
using value_type = oe::InternalExtractorEdge;
|
||||
bool operator()(const value_type &lhs, const value_type &rhs) const
|
||||
{
|
||||
return lhs.result.osm_source_id < rhs.result.osm_source_id;
|
||||
}
|
||||
|
||||
value_type max_value() { return value_type::max_osm_value(); }
|
||||
value_type min_value() { return value_type::min_osm_value(); }
|
||||
};
|
||||
|
||||
struct CmpEdgeByOSMTargetID
|
||||
{
|
||||
using value_type = oe::InternalExtractorEdge;
|
||||
bool operator()(const value_type &lhs, const value_type &rhs) const
|
||||
{
|
||||
return lhs.result.osm_target_id < rhs.result.osm_target_id;
|
||||
}
|
||||
|
||||
value_type max_value() { return value_type::max_osm_value(); }
|
||||
value_type min_value() { return value_type::min_osm_value(); }
|
||||
};
|
||||
|
||||
struct CmpEdgeByInternalSourceTargetAndName
|
||||
{
|
||||
using value_type = oe::InternalExtractorEdge;
|
||||
bool operator()(const value_type &lhs, const value_type &rhs) const
|
||||
{
|
||||
if (lhs.result.source != rhs.result.source)
|
||||
return lhs.result.source < rhs.result.source;
|
||||
|
||||
if (lhs.result.target != rhs.result.target)
|
||||
return lhs.result.target < rhs.result.target;
|
||||
|
||||
if (lhs.result.source == SPECIAL_NODEID)
|
||||
return false;
|
||||
|
||||
if (lhs.result.name_id == rhs.result.name_id)
|
||||
return false;
|
||||
|
||||
if (lhs.result.name_id == EMPTY_NAMEID)
|
||||
return false;
|
||||
|
||||
if (rhs.result.name_id == EMPTY_NAMEID)
|
||||
return true;
|
||||
|
||||
BOOST_ASSERT(!name_offsets.empty() && name_offsets.back() == name_data.size());
|
||||
const oe::ExtractionContainers::STXXLNameCharData::const_iterator data = name_data.begin();
|
||||
return std::lexicographical_compare(data + name_offsets[lhs.result.name_id],
|
||||
data + name_offsets[lhs.result.name_id + 1],
|
||||
data + name_offsets[rhs.result.name_id],
|
||||
data + name_offsets[rhs.result.name_id + 1]);
|
||||
}
|
||||
|
||||
value_type max_value() { return value_type::max_internal_value(); }
|
||||
value_type min_value() { return value_type::min_internal_value(); }
|
||||
|
||||
const oe::ExtractionContainers::STXXLNameCharData &name_data;
|
||||
const oe::ExtractionContainers::STXXLNameOffsets &name_offsets;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
namespace osrm
|
||||
@@ -48,10 +113,13 @@ ExtractionContainers::ExtractionContainers()
|
||||
{
|
||||
// Check if stxxl can be instantiated
|
||||
stxxl::vector<unsigned> dummy_vector;
|
||||
// Insert three empty strings for name, destination and pronunciation
|
||||
name_lengths.push_back(0);
|
||||
name_lengths.push_back(0);
|
||||
name_lengths.push_back(0);
|
||||
|
||||
// Insert three empty strings offsets for name, destination and pronunciation
|
||||
name_offsets.push_back(0);
|
||||
name_offsets.push_back(0);
|
||||
name_offsets.push_back(0);
|
||||
// Insert the total length sentinel (corresponds to the next name string offset)
|
||||
name_offsets.push_back(0);
|
||||
|
||||
// the offsets have to be initialized with two values, since we have the empty turn string for
|
||||
// the first id
|
||||
@@ -90,7 +158,7 @@ void ExtractionContainers::PrepareData(const std::string &output_file_name,
|
||||
PrepareRestrictions();
|
||||
WriteRestrictions(restrictions_file_name);
|
||||
|
||||
WriteCharData(name_file_name, name_lengths, name_char_data);
|
||||
WriteCharData(name_file_name);
|
||||
WriteTurnLaneMasks(turn_lane_file_name, turn_lane_offsets, turn_lane_masks);
|
||||
}
|
||||
catch (const std::exception &e)
|
||||
@@ -125,23 +193,26 @@ void ExtractionContainers::WriteTurnLaneMasks(
|
||||
util::SimpleLogger().Write() << "done (" << TIMER_SEC(turn_lane_timer) << ")";
|
||||
}
|
||||
|
||||
void ExtractionContainers::WriteCharData(const std::string &file_name,
|
||||
const stxxl::vector<unsigned> &offsets,
|
||||
const stxxl::vector<char> &char_data) const
|
||||
void ExtractionContainers::WriteCharData(const std::string &file_name)
|
||||
{
|
||||
std::cout << "[extractor] writing street name index ... " << std::flush;
|
||||
TIMER_START(write_index);
|
||||
boost::filesystem::ofstream file_stream(file_name, std::ios::binary);
|
||||
|
||||
unsigned total_length = 0;
|
||||
|
||||
for (const auto length : offsets)
|
||||
// transforms in-place name offsets to name lengths
|
||||
BOOST_ASSERT(!name_offsets.empty());
|
||||
for (auto curr = name_offsets.begin(), next = name_offsets.begin() + 1;
|
||||
next != name_offsets.end(); ++curr, ++next)
|
||||
{
|
||||
total_length += length;
|
||||
*curr = *next - *curr;
|
||||
}
|
||||
|
||||
// removes the total length sentinel
|
||||
unsigned total_length = name_offsets.back();
|
||||
name_offsets.pop_back();
|
||||
|
||||
// builds and writes the index
|
||||
util::RangeTable<> index_range(offsets);
|
||||
util::RangeTable<> index_range(name_offsets);
|
||||
file_stream << index_range;
|
||||
|
||||
file_stream.write((char *)&total_length, sizeof(unsigned));
|
||||
@@ -150,7 +221,7 @@ void ExtractionContainers::WriteCharData(const std::string &file_name,
|
||||
char write_buffer[WRITE_BLOCK_BUFFER_SIZE];
|
||||
unsigned buffer_len = 0;
|
||||
|
||||
for (const auto c : char_data)
|
||||
for (const auto c : name_char_data)
|
||||
{
|
||||
write_buffer[buffer_len++] = c;
|
||||
|
||||
@@ -416,7 +487,7 @@ void ExtractionContainers::PrepareEdges(lua_State *segment_state)
|
||||
TIMER_START(sort_edges_by_renumbered_start);
|
||||
stxxl::sort(all_edges_list.begin(),
|
||||
all_edges_list.end(),
|
||||
CmpEdgeByInternalStartThenInternalTargetID(),
|
||||
CmpEdgeByInternalSourceTargetAndName{name_char_data, name_offsets},
|
||||
stxxl_memory);
|
||||
TIMER_STOP(sort_edges_by_renumbered_start);
|
||||
std::cout << "ok, after " << TIMER_SEC(sort_edges_by_renumbered_start) << "s" << std::endl;
|
||||
@@ -453,11 +524,13 @@ void ExtractionContainers::PrepareEdges(lua_State *segment_state)
|
||||
all_edges_list[i].result.weight < min_forward_weight)
|
||||
{
|
||||
min_forward_idx = i;
|
||||
min_forward_weight = all_edges_list[i].result.weight;
|
||||
}
|
||||
if (all_edges_list[i].result.backward &&
|
||||
all_edges_list[i].result.weight < min_backward_weight)
|
||||
{
|
||||
min_backward_idx = i;
|
||||
min_backward_weight = all_edges_list[i].result.weight;
|
||||
}
|
||||
|
||||
// this also increments the outer loop counter!
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
#include "extractor/extractor_callbacks.hpp"
|
||||
#include "extractor/external_memory_node.hpp"
|
||||
#include "extractor/extraction_containers.hpp"
|
||||
#include "extractor/extraction_node.hpp"
|
||||
#include "extractor/extraction_way.hpp"
|
||||
#include "extractor/extractor_callbacks.hpp"
|
||||
#include "extractor/restriction.hpp"
|
||||
|
||||
#include "util/for_each_pair.hpp"
|
||||
@@ -154,7 +154,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
|
||||
TurnLaneDescription lane_description;
|
||||
|
||||
typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
|
||||
boost::char_separator<char> sep("|&", "", boost::keep_empty_tokens);
|
||||
boost::char_separator<char> sep("|", "", boost::keep_empty_tokens);
|
||||
boost::char_separator<char> inner_sep(";", "");
|
||||
tokenizer tokens(lane_string, sep);
|
||||
|
||||
@@ -215,7 +215,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
|
||||
// convert the lane description into an ID and, if necessary, remembr the description in the
|
||||
// description_map
|
||||
const auto requestId = [&](std::string lane_string) {
|
||||
if( lane_string.empty() )
|
||||
if (lane_string.empty())
|
||||
return INVALID_LANE_DESCRIPTIONID;
|
||||
TurnLaneDescription lane_description = laneStringToDescription(std::move(lane_string));
|
||||
|
||||
@@ -253,33 +253,35 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
|
||||
// Get the unique identifier for the street name
|
||||
// Get the unique identifier for the street name and destination
|
||||
const auto name_iterator = string_map.find(MapKey(parsed_way.name, parsed_way.destinations));
|
||||
unsigned name_id = external_memory.name_lengths.size();
|
||||
unsigned name_id = EMPTY_NAMEID;
|
||||
if (string_map.end() == name_iterator)
|
||||
{
|
||||
auto name_length = std::min<unsigned>(MAX_STRING_LENGTH, parsed_way.name.size());
|
||||
auto destinations_length =
|
||||
const auto name_length = std::min<unsigned>(MAX_STRING_LENGTH, parsed_way.name.size());
|
||||
const auto destinations_length =
|
||||
std::min<unsigned>(MAX_STRING_LENGTH, parsed_way.destinations.size());
|
||||
auto pronunciation_length =
|
||||
const auto pronunciation_length =
|
||||
std::min<unsigned>(MAX_STRING_LENGTH, parsed_way.pronunciation.size());
|
||||
|
||||
external_memory.name_char_data.reserve(name_id + name_length + destinations_length +
|
||||
pronunciation_length);
|
||||
// name_offsets already has an offset of a new name, take the offset index as the name id
|
||||
name_id = external_memory.name_offsets.size() - 1;
|
||||
|
||||
external_memory.name_char_data.reserve(external_memory.name_char_data.size() + name_length
|
||||
+ destinations_length + pronunciation_length);
|
||||
|
||||
std::copy(parsed_way.name.c_str(),
|
||||
parsed_way.name.c_str() + name_length,
|
||||
std::back_inserter(external_memory.name_char_data));
|
||||
external_memory.name_offsets.push_back(external_memory.name_char_data.size());
|
||||
|
||||
std::copy(parsed_way.destinations.c_str(),
|
||||
parsed_way.destinations.c_str() + destinations_length,
|
||||
std::back_inserter(external_memory.name_char_data));
|
||||
external_memory.name_offsets.push_back(external_memory.name_char_data.size());
|
||||
|
||||
std::copy(parsed_way.pronunciation.c_str(),
|
||||
parsed_way.pronunciation.c_str() + pronunciation_length,
|
||||
std::back_inserter(external_memory.name_char_data));
|
||||
|
||||
external_memory.name_lengths.push_back(name_length);
|
||||
external_memory.name_lengths.push_back(destinations_length);
|
||||
external_memory.name_lengths.push_back(pronunciation_length);
|
||||
external_memory.name_offsets.push_back(external_memory.name_char_data.size());
|
||||
|
||||
auto k = MapKey{parsed_way.name, parsed_way.destinations};
|
||||
auto v = MapVal{name_id};
|
||||
|
||||
@@ -34,7 +34,7 @@ IntersectionHandler::IntersectionHandler(const util::NodeBasedDynamicGraph &node
|
||||
{
|
||||
}
|
||||
|
||||
IntersectionHandler::~IntersectionHandler() {}
|
||||
IntersectionHandler::~IntersectionHandler() = default;
|
||||
|
||||
std::size_t IntersectionHandler::countValid(const Intersection &intersection) const
|
||||
{
|
||||
|
||||
@@ -47,7 +47,7 @@ MotorwayHandler::MotorwayHandler(const util::NodeBasedDynamicGraph &node_based_g
|
||||
{
|
||||
}
|
||||
|
||||
MotorwayHandler::~MotorwayHandler() {}
|
||||
MotorwayHandler::~MotorwayHandler() = default;
|
||||
|
||||
bool MotorwayHandler::canProcess(const NodeID,
|
||||
const EdgeID via_eid,
|
||||
|
||||
@@ -31,7 +31,7 @@ RoundaboutHandler::RoundaboutHandler(const util::NodeBasedDynamicGraph &node_bas
|
||||
{
|
||||
}
|
||||
|
||||
RoundaboutHandler::~RoundaboutHandler() {}
|
||||
RoundaboutHandler::~RoundaboutHandler() = default;
|
||||
|
||||
bool RoundaboutHandler::canProcess(const NodeID from_nid,
|
||||
const EdgeID via_eid,
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#include "extractor/guidance/turn_handler.hpp"
|
||||
#include "extractor/guidance/constants.hpp"
|
||||
#include "extractor/guidance/intersection_scenario_three_way.hpp"
|
||||
#include "extractor/guidance/toolkit.hpp"
|
||||
#include "extractor/guidance/turn_handler.hpp"
|
||||
|
||||
#include "util/guidance/toolkit.hpp"
|
||||
|
||||
@@ -29,7 +29,7 @@ TurnHandler::TurnHandler(const util::NodeBasedDynamicGraph &node_based_graph,
|
||||
{
|
||||
}
|
||||
|
||||
TurnHandler::~TurnHandler() {}
|
||||
TurnHandler::~TurnHandler() = default;
|
||||
|
||||
bool TurnHandler::canProcess(const NodeID, const EdgeID, const Intersection &) const
|
||||
{
|
||||
@@ -88,18 +88,20 @@ Intersection TurnHandler::handleThreeWayTurn(const EdgeID via_edge, Intersection
|
||||
|
||||
const bool is_ramp = isRampClass(first_class);
|
||||
const bool is_obvious_by_road_class =
|
||||
(!is_ramp && (2 * getPriority(first_class) < getPriority(second_class))) ||
|
||||
(!is_ramp && (2 * getPriority(first_class) < getPriority(second_class)) &&
|
||||
in_data.road_classification.road_class == first_class) ||
|
||||
(!isLowPriorityRoadClass(first_class) && isLowPriorityRoadClass(second_class));
|
||||
|
||||
if (is_obvious_by_road_class)
|
||||
return true;
|
||||
|
||||
const bool other_is_obvious_by_road_flass =
|
||||
const bool other_is_obvious_by_road_class =
|
||||
(!isRampClass(second_class) &&
|
||||
(2 * getPriority(second_class) < getPriority(first_class))) ||
|
||||
(2 * getPriority(second_class) < getPriority(first_class)) &&
|
||||
in_data.road_classification.road_class == second_class) ||
|
||||
(!isLowPriorityRoadClass(second_class) && isLowPriorityRoadClass(first_class));
|
||||
|
||||
if (other_is_obvious_by_road_flass)
|
||||
if (other_is_obvious_by_road_class)
|
||||
return false;
|
||||
|
||||
const bool turn_is_perfectly_straight = angularDeviation(road.turn.angle, STRAIGHT_ANGLE) <
|
||||
@@ -375,6 +377,7 @@ std::size_t TurnHandler::findObviousTurn(const EdgeID via_edge,
|
||||
double best_continue_deviation = 180;
|
||||
|
||||
const EdgeData &in_data = node_based_graph.GetEdgeData(via_edge);
|
||||
const auto in_class = in_data.road_classification.road_class;
|
||||
for (std::size_t i = 1; i < intersection.size(); ++i)
|
||||
{
|
||||
const double deviation = angularDeviation(intersection[i].turn.angle, STRAIGHT_ANGLE);
|
||||
@@ -388,9 +391,11 @@ std::size_t TurnHandler::findObviousTurn(const EdgeID via_edge,
|
||||
auto continue_class = node_based_graph.GetEdgeData(intersection[best_continue].turn.eid)
|
||||
.road_classification.road_class;
|
||||
if (intersection[i].entry_allowed && out_data.name_id == in_data.name_id &&
|
||||
(best_continue == 0 || continue_class > out_data.road_classification.road_class ||
|
||||
(best_continue == 0 || (continue_class > out_data.road_classification.road_class &&
|
||||
in_class != continue_class) ||
|
||||
(deviation < best_continue_deviation &&
|
||||
out_data.road_classification.road_class == continue_class)))
|
||||
(out_data.road_classification.road_class == continue_class ||
|
||||
in_class == out_data.road_classification.road_class))))
|
||||
{
|
||||
best_continue_deviation = deviation;
|
||||
best_continue = i;
|
||||
|
||||
@@ -120,7 +120,7 @@ LaneDataVector augmentMultiple(const std::size_t none_index,
|
||||
}
|
||||
}
|
||||
lane_data.erase(lane_data.begin() + none_index);
|
||||
return std::move(lane_data);
|
||||
return lane_data;
|
||||
}
|
||||
|
||||
// Merging none-tag into its neighboring fields
|
||||
@@ -146,7 +146,7 @@ LaneDataVector mergeNoneTag(const std::size_t none_index, LaneDataVector lane_da
|
||||
|
||||
lane_data.erase(lane_data.begin() + none_index);
|
||||
}
|
||||
return std::move(lane_data);
|
||||
return lane_data;
|
||||
}
|
||||
|
||||
LaneDataVector handleRenamingSituations(const std::size_t none_index,
|
||||
@@ -222,7 +222,7 @@ LaneDataVector handleRenamingSituations(const std::size_t none_index,
|
||||
lane_data[none_index].tag = TurnLaneType::straight;
|
||||
}
|
||||
}
|
||||
return std::move(lane_data);
|
||||
return lane_data;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
@@ -239,7 +239,7 @@ LaneDataVector handleNoneValueAtSimpleTurn(LaneDataVector lane_data,
|
||||
(intersection.empty() || lane_data.empty() || !hasTag(TurnLaneType::none, lane_data));
|
||||
|
||||
if (needs_no_processing)
|
||||
return std::move(lane_data);
|
||||
return lane_data;
|
||||
|
||||
// FIXME all this needs to consider the number of lanes at the target to ensure that we
|
||||
// augment lanes correctly, if the target lane allows for more turns
|
||||
@@ -294,7 +294,7 @@ LaneDataVector handleNoneValueAtSimpleTurn(LaneDataVector lane_data,
|
||||
}
|
||||
// finally make sure we are still sorted
|
||||
std::sort(lane_data.begin(), lane_data.end());
|
||||
return std::move(lane_data);
|
||||
return lane_data;
|
||||
}
|
||||
|
||||
} // namespace lanes
|
||||
|
||||
@@ -45,11 +45,6 @@ bool TurnLaneData::operator<(const TurnLaneData &other) const
|
||||
LaneDataVector laneDataFromDescription(const TurnLaneDescription &turn_lane_description)
|
||||
{
|
||||
typedef std::unordered_map<TurnLaneType::Mask, std::pair<LaneID, LaneID>> LaneMap;
|
||||
|
||||
// FIXME this is a workaround due to https://github.com/cucumber/cucumber-js/issues/417,
|
||||
// need to switch statements when fixed
|
||||
// const auto num_lanes = std::count(turn_lane_string.begin(), turn_lane_string.end(), '|') + 1;
|
||||
// count the number of lanes
|
||||
const auto num_lanes = boost::numeric_cast<LaneID>(turn_lane_description.size());
|
||||
const auto setLaneData = [&](
|
||||
LaneMap &map, TurnLaneType::Mask full_mask, const LaneID current_lane) {
|
||||
|
||||
@@ -65,7 +65,7 @@ Intersection TurnLaneHandler::assignTurnLanes(const NodeID at,
|
||||
{
|
||||
//if only a uturn exists, there is nothing we can do
|
||||
if( intersection.size() == 1 )
|
||||
return std::move(intersection);
|
||||
return intersection;
|
||||
|
||||
const auto &data = node_based_graph.GetEdgeData(via_edge);
|
||||
// Extract a lane description for the ID
|
||||
@@ -85,19 +85,19 @@ Intersection TurnLaneHandler::assignTurnLanes(const NodeID at,
|
||||
data.lane_description_id ==
|
||||
node_based_graph.GetEdgeData(intersection[1].turn.eid).lane_description_id) ||
|
||||
angularDeviation(intersection[1].turn.angle, STRAIGHT_ANGLE) < FUZZY_ANGLE_DIFFERENCE))
|
||||
return std::move(intersection);
|
||||
return intersection;
|
||||
|
||||
auto lane_data = laneDataFromDescription(turn_lane_description);
|
||||
|
||||
// if we see an invalid conversion, we stop immediately
|
||||
if (!turn_lane_description.empty() && lane_data.empty())
|
||||
return std::move(intersection);
|
||||
return intersection;
|
||||
|
||||
// might be reasonable to handle multiple turns, if we know of a sequence of lanes
|
||||
// e.g. one direction per lane, if three lanes and right, through, left available
|
||||
if (!turn_lane_description.empty() && lane_data.size() == 1 &&
|
||||
lane_data[0].tag == TurnLaneType::none)
|
||||
return std::move(intersection);
|
||||
return intersection;
|
||||
|
||||
const std::size_t possible_entries = getNumberOfTurns(intersection);
|
||||
|
||||
@@ -114,7 +114,7 @@ Intersection TurnLaneHandler::assignTurnLanes(const NodeID at,
|
||||
lane_data.size() + 1 == possible_entries);
|
||||
|
||||
if (has_merge_lane || has_non_usable_u_turn)
|
||||
return std::move(intersection);
|
||||
return intersection;
|
||||
|
||||
if (!lane_data.empty() && canMatchTrivially(intersection, lane_data) &&
|
||||
lane_data.size() !=
|
||||
@@ -165,7 +165,7 @@ Intersection TurnLaneHandler::assignTurnLanes(const NodeID at,
|
||||
return handleTurnAtPreviousIntersection(at, via_edge, std::move(intersection), id_map);
|
||||
}
|
||||
|
||||
return std::move(intersection);
|
||||
return intersection;
|
||||
}
|
||||
|
||||
// At segregated intersections, turn lanes will often only be specified up until the first turn. To
|
||||
@@ -221,11 +221,11 @@ Intersection TurnLaneHandler::handleTurnAtPreviousIntersection(const NodeID at,
|
||||
|
||||
// no lane string, no problems
|
||||
if (previous_lane_description.empty())
|
||||
return std::move(intersection);
|
||||
return intersection;
|
||||
|
||||
// stop on invalid lane data conversion
|
||||
if (lane_data.empty())
|
||||
return std::move(intersection);
|
||||
return intersection;
|
||||
|
||||
const auto &previous_data = node_based_graph.GetEdgeData(previous_id);
|
||||
const auto is_simple = isSimpleIntersection(lane_data, intersection);
|
||||
@@ -257,7 +257,7 @@ Intersection TurnLaneHandler::handleTurnAtPreviousIntersection(const NodeID at,
|
||||
}
|
||||
}
|
||||
}
|
||||
return std::move(intersection);
|
||||
return intersection;
|
||||
}
|
||||
|
||||
/* A simple intersection does not depend on the next intersection coming up. This is important
|
||||
@@ -522,7 +522,7 @@ Intersection TurnLaneHandler::simpleMatchTuplesToTurns(Intersection intersection
|
||||
LaneDataIdMap &id_map) const
|
||||
{
|
||||
if (lane_data.empty() || !canMatchTrivially(intersection, lane_data))
|
||||
return std::move(intersection);
|
||||
return intersection;
|
||||
|
||||
BOOST_ASSERT(
|
||||
!hasTag(TurnLaneType::none | TurnLaneType::merge_to_left | TurnLaneType::merge_to_right,
|
||||
|
||||
@@ -236,7 +236,7 @@ Intersection triviallyMatchLanesToTurns(Intersection intersection,
|
||||
DirectionModifier::SharpLeft)
|
||||
{
|
||||
// cannot match u-turn in a valid way
|
||||
return std::move(intersection);
|
||||
return intersection;
|
||||
}
|
||||
u_turn = intersection.size() - 1;
|
||||
}
|
||||
@@ -246,7 +246,7 @@ Intersection triviallyMatchLanesToTurns(Intersection intersection,
|
||||
|
||||
matchRoad(intersection[u_turn], lane_data.back());
|
||||
}
|
||||
return std::move(intersection);
|
||||
return intersection;
|
||||
}
|
||||
|
||||
} // namespace lane_matching
|
||||
|
||||
@@ -49,6 +49,7 @@ void RequestHandler::HandleRequest(const http::request ¤t_request, http::r
|
||||
{
|
||||
std::string request_string;
|
||||
util::URIDecode(current_request.uri, request_string);
|
||||
util::SimpleLogger().Write(logDEBUG) << "req: " << request_string;
|
||||
|
||||
auto api_iterator = request_string.begin();
|
||||
auto maybe_parsed_url = api::parseURL(api_iterator, request_string.end());
|
||||
|
||||
@@ -152,7 +152,7 @@ int Storage::Run()
|
||||
if (!util::deserializeAdjacencyArray(config.turn_lane_description_path.string(),
|
||||
lane_description_offsets,
|
||||
lane_description_masks))
|
||||
throw util::exception("Could not open read lane descriptions from: " +
|
||||
throw util::exception("Failed to read lane descriptions from: " +
|
||||
config.turn_lane_description_path.string());
|
||||
shared_layout_ptr->SetBlockSize<std::uint32_t>(SharedDataLayout::LANE_DESCRIPTION_OFFSETS,
|
||||
lane_description_offsets.size());
|
||||
|
||||
Reference in New Issue
Block a user