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

expose data about turning onto restricted roads to turn function

Browse Source
This commit is contained in:
karenzshea 2017-02-14 12:59:16 +01:00 committed by Patrick Niklaus
parent a0e7bab598
commit c2727f2029
19 changed files with 210 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
features/car/access.feature
View File

@ -119,12 +119,13 @@ Feature: Car - Restricted access
| permissive | x | | permissive | x |
| designated | x | | designated | x |
| no | | | no | |
| private | | | private | x |
| agricultural | | | agricultural | |
| forestry | | | forestry | |
| psv | | | psv | |
| delivery | | | delivery | x |
| some_tag | x | | some_tag | x |
| destination | x |
Scenario: Car - Access tags on nodes Scenario: Car - Access tags on nodes
@ -134,11 +135,11 @@ Feature: Car - Restricted access
| permissive | x | | permissive | x |
| designated | x | | designated | x |
| no | | | no | |
| private | | | private | x |
| agricultural | | | agricultural | |
| forestry | | | forestry | |
| psv | | | psv | |
| delivery | | | delivery | x |
| some_tag | x | | some_tag | x |
Scenario: Car - Access tags on both node and way Scenario: Car - Access tags on both node and way
@ -156,15 +157,15 @@ Feature: Car - Restricted access
Scenario: Car - Access combinations Scenario: Car - Access combinations
Then routability should be Then routability should be
| highway | accesss | vehicle | motor_vehicle | motorcar | bothw | | highway | access | vehicle | motor_vehicle | motorcar | forw | backw | # |
| runway | private | | | permissive | x | | runway | private | | | permissive | x | x | |
| primary | forestry | | yes | | x | | primary | forestry | | yes | | x | x | |
| cycleway | | | designated | | x | | cycleway | | | designated | | x | x | |
| residential | | yes | no | | | | residential | | yes | no | | | | |
| motorway | yes | permissive | | private | | | motorway | yes | permissive | | private | x | | implied oneway |
| trunk | agricultural | designated | permissive | no | | | trunk | agricultural | designated | permissive | no | | | |
| pedestrian | | | | | | | pedestrian | | | | | | | |
| pedestrian | | | | destination | x | | pedestrian | | | | destination | x | x | |
Scenario: Car - Ignore access tags for other modes Scenario: Car - Ignore access tags for other modes
Then routability should be Then routability should be
@ -182,7 +183,7 @@ Feature: Car - Restricted access
Scenario: Car - designated HOV ways are rated low Scenario: Car - designated HOV ways are rated low
Then routability should be Then routability should be
| highway | hov | bothw | forw_rate | backw_rate | | highway | hov | bothw | forw_rate | backw_rate |
| primary | designated | x | 2 | 2 | | primary | designated | x | 18 | 18 |
| primary | yes | x | 18 | 18 | | primary | yes | x | 18 | 18 |
| primary | no | x | 18 | 18 | | primary | no | x | 18 | 18 |
@ -193,28 +194,28 @@ Feature: Car - Restricted access
Scenario: Car - I-66 use HOV-only roads with heavy penalty Scenario: Car - I-66 use HOV-only roads with heavy penalty
Then routability should be Then routability should be
| highway | hov | hov:lanes | lanes | access | oneway | forw | backw | forw_rate | | highway | hov | hov:lanes | lanes | access | oneway | forw | backw | forw_rate |
| motorway | designated | designated\|designated\|designated | 3 | hov | yes | x | | 3 | | motorway | designated | designated\|designated\|designated | 3 | hov | yes | x | | 25 |
| motorway | lane | | 3 | designated | yes | x | | 25 | | motorway | lane | | 3 | designated | yes | x | | 25 |
@hov @hov
Scenario: Car - a way with all lanes HOV-designated is highly penalized by default (similar to hov=designated) Scenario: Car - a way with all lanes HOV-designated is highly penalized by default (similar to hov=designated)
Then routability should be Then routability should be
| highway | hov:lanes:forward | hov:lanes:backward | hov:lanes | oneway | forw | backw | forw_rate | backw_rate | | highway | hov:lanes:forward | hov:lanes:backward | hov:lanes | oneway | forw | backw | forw_rate | backw_rate |
| primary | designated | designated | | | x | x | 2 | 2 | | primary | designated | designated | | | x | x | 18 | 18 |
| primary | | designated | | | x | x | 18 | 2 | | primary | | designated | | | x | x | 18 | 18 |
| primary | designated | | | | x | x | 2 | 18 | | primary | designated | | | | x | x | 18 | 18 |
| primary | designated\|designated | designated\|designated | | | x | x | 2 | 2 | | primary | designated\|designated | designated\|designated | | | x | x | 18 | 18 |
| primary | designated\|no | designated\|no | | | x | x | 18 | 18 | | primary | designated\|no | designated\|no | | | x | x | 18 | 18 |
| primary | yes\|no | yes\|no | | | x | x | 18 | 18 | | primary | yes\|no | yes\|no | | | x | x | 18 | 18 |
| primary | | | | | x | x | 18 | 18 | | primary | | | | | x | x | 18 | 18 |
| primary | designated | | | -1 | | x | | 18 | | primary | designated | | | -1 | | x | | 18 |
| primary | | designated | | -1 | | x | | 2 | | primary | | designated | | -1 | | x | | 18 |
| primary | | | designated | yes | x | | 2 | | | primary | | | designated | yes | x | | 18 | |
| primary | | | designated | -1 | | x | | 2 | | primary | | | designated | -1 | | x | | 18 |
| primary | | | designated\| | yes | x | | 18 | | | primary | | | designated\| | yes | x | | 18 | |
| primary | | | designated\| | -1 | | x | | 18 | | primary | | | designated\| | -1 | | x | | 18 |
| primary | | | designated\|designated | yes | x | | 2 | | | primary | | | designated\|designated | yes | x | | 18 | |
| primary | | | designated\|designated | -1 | | x | | 2 | | primary | | | designated\|designated | -1 | | x | | 18 |
| primary | | | designated\|yes | yes | x | | 18 | | | primary | | | designated\|yes | yes | x | | 18 | |
| primary | | | designated\|no | -1 | | x | | 18 | | primary | | | designated\|no | -1 | | x | | 18 |
@ -250,7 +251,7 @@ Feature: Car - Restricted access
| gate | yes | x | | gate | yes | x |
| gate | permissive | x | | gate | permissive | x |
| gate | designated | x | | gate | designated | x |
| gate | private | | | gate | private | x |
| gate | garbagetag | x | | gate | garbagetag | x |
Scenario: Car - a way with conditional access Scenario: Car - a way with conditional access

4
features/car/barrier.feature
View File

@ -29,14 +29,14 @@ Feature: Car - Barriers
| gate | permissive | x | | gate | permissive | x |
| gate | designated | x | | gate | designated | x |
| gate | no | | | gate | no | |
| gate | private | | | gate | private | x |
| gate | agricultural | | | gate | agricultural | |
| wall | | | | wall | | |
| wall | yes | x | | wall | yes | x |
| wall | permissive | x | | wall | permissive | x |
| wall | designated | x | | wall | designated | x |
| wall | no | | | wall | no | |
| wall | private | | | wall | private | x |
| wall | agricultural | | | wall | agricultural | |
Scenario: Car - Rising bollard exception for barriers Scenario: Car - Rising bollard exception for barriers

2
features/car/destination.feature
View File

@ -1,4 +1,4 @@
@routing @car @destination @todo @routing @car @destination
Feature: Car - Destination only, no passing through Feature: Car - Destination only, no passing through
Background: Background:

36
features/car/hov.feature Normal file
View File

@ -0,0 +1,36 @@
@routing @car @hov
Feature: Car - Handle driving
Background:
Given the profile "car"
And a grid size of 100 meters
Scenario: Car - Avoid hov when not on hov
Given the node map
"""
b=========c========================e====j
~ ~ ~
a ~ f----m
| i |
| | ----------------l
| | /
g_______________h______k_____n
"""
And the ways
| nodes | highway | hov |
| ab | motorway_link | |
| bcej | motorway | designated |
| ag | primary | |
| ghkn | primary | |
| ih | primary | |
| kl | secondary | |
| lf | secondary | |
| ci | motorway_link | |
| ef | motorway_link | |
| fm | secondary | |
When I route I should get
| from | to | route |
| a | m | ag,ghkn,kl,lf,fm,fm |
| c | m | bcej,ef,fm,fm |

4
features/car/surface.feature
View File

@ -40,13 +40,13 @@ Feature: Car - Surfaces
| highway | access | tracktype | smoothness | surface | forw | backw | | highway | access | tracktype | smoothness | surface | forw | backw |
| motorway | | | | | x | | | motorway | | | | | x | |
| motorway | no | grade1 | excellent | asphalt | | | | motorway | no | grade1 | excellent | asphalt | | |
| motorway | private | grade1 | excellent | asphalt | | | | motorway | private | grade1 | excellent | asphalt | x | |
| motorway | agricultural | grade1 | excellent | asphalt | | | | motorway | agricultural | grade1 | excellent | asphalt | | |
| motorway | forestry | grade1 | excellent | asphalt | | | | motorway | forestry | grade1 | excellent | asphalt | | |
| motorway | emergency | grade1 | excellent | asphalt | | | | motorway | emergency | grade1 | excellent | asphalt | | |
| primary | | | | | x | x | | primary | | | | | x | x |
| primary | private | grade1 | excellent | asphalt | x | x |
| primary | no | grade1 | excellent | asphalt | | | | primary | no | grade1 | excellent | asphalt | | |
| primary | private | grade1 | excellent | asphalt | | |
| primary | agricultural | grade1 | excellent | asphalt | | | | primary | agricultural | grade1 | excellent | asphalt | | |
| primary | forestry | grade1 | excellent | asphalt | | | | primary | forestry | grade1 | excellent | asphalt | | |
| primary | emergency | grade1 | excellent | asphalt | | | | primary | emergency | grade1 | excellent | asphalt | | |

5
include/extractor/extraction_turn.hpp
View File

@ -17,7 +17,8 @@ struct ExtractionTurn
ExtractionTurn(const guidance::ConnectedRoad &turn, bool has_traffic_light) ExtractionTurn(const guidance::ConnectedRoad &turn, bool has_traffic_light)
: angle(180. - turn.angle), turn_type(turn.instruction.type), : angle(180. - turn.angle), turn_type(turn.instruction.type),
direction_modifier(turn.instruction.direction_modifier), direction_modifier(turn.instruction.direction_modifier),
has_traffic_light(has_traffic_light), weight(0.), duration(0.) has_traffic_light(has_traffic_light), weight(0.), duration(0.), source_restricted(false),
target_restricted(false)
{ {
} }
@ -27,6 +28,8 @@ struct ExtractionTurn
const bool has_traffic_light; const bool has_traffic_light;
double weight; double weight;
double duration; double duration;
bool source_restricted;
bool target_restricted;
}; };
} }
} }

4
include/extractor/extraction_way.hpp
View File

@ -58,6 +58,8 @@ struct ExtractionWay
turn_lanes_forward.clear(); turn_lanes_forward.clear();
turn_lanes_backward.clear(); turn_lanes_backward.clear();
road_classification = guidance::RoadClassification(); road_classification = guidance::RoadClassification();
backward_restricted = false;
forward_restricted = false;
} }
// These accessors exists because it's not possible to take the address of a bitfield, // These accessors exists because it's not possible to take the address of a bitfield,
@ -106,6 +108,8 @@ struct ExtractionWay
bool roundabout; bool roundabout;
bool circular; bool circular;
bool is_startpoint; bool is_startpoint;
bool backward_restricted;
bool forward_restricted;
TravelMode forward_travel_mode : 4; TravelMode forward_travel_mode : 4;
TravelMode backward_travel_mode : 4; TravelMode backward_travel_mode : 4;
guidance::RoadClassification road_classification; guidance::RoadClassification road_classification;

15
include/extractor/internal_extractor_edge.hpp
View File

@ -70,8 +70,9 @@ struct InternalExtractorEdge
false, // roundabout false, // roundabout
false, // circular false, // circular
true, // can be startpoint true, // can be startpoint
false, // local access only
false, // split edge
TRAVEL_MODE_INACCESSIBLE, TRAVEL_MODE_INACCESSIBLE,
false,
guidance::TurnLaneType::empty, guidance::TurnLaneType::empty,
guidance::RoadClassification()), guidance::RoadClassification()),
weight_data(), duration_data() weight_data(), duration_data()
@ -88,8 +89,9 @@ struct InternalExtractorEdge
bool roundabout, bool roundabout,
bool circular, bool circular,
bool startpoint, bool startpoint,
TravelMode travel_mode, bool restricted,
bool is_split, bool is_split,
TravelMode travel_mode,
LaneDescriptionID lane_description, LaneDescriptionID lane_description,
guidance::RoadClassification road_classification, guidance::RoadClassification road_classification,
util::Coordinate source_coordinate) util::Coordinate source_coordinate)
@ -103,8 +105,9 @@ struct InternalExtractorEdge
roundabout, roundabout,
circular, circular,
startpoint, startpoint,
travel_mode, restricted,
is_split, is_split,
travel_mode,
lane_description, lane_description,
std::move(road_classification)), std::move(road_classification)),
weight_data(std::move(weight_data)), duration_data(std::move(duration_data)), weight_data(std::move(weight_data)), duration_data(std::move(duration_data)),
@ -134,8 +137,9 @@ struct InternalExtractorEdge
false, // roundabout false, // roundabout
false, // circular false, // circular
true, // can be startpoint true, // can be startpoint
false, // local access only
false, // split edge
TRAVEL_MODE_INACCESSIBLE, TRAVEL_MODE_INACCESSIBLE,
false,
INVALID_LANE_DESCRIPTIONID, INVALID_LANE_DESCRIPTIONID,
guidance::RoadClassification(), guidance::RoadClassification(),
util::Coordinate()); util::Coordinate());
@ -152,8 +156,9 @@ struct InternalExtractorEdge
false, // roundabout false, // roundabout
false, // circular false, // circular
true, // can be startpoint true, // can be startpoint
false, // local access only
false, // split edge
TRAVEL_MODE_INACCESSIBLE, TRAVEL_MODE_INACCESSIBLE,
false,
INVALID_LANE_DESCRIPTIONID, INVALID_LANE_DESCRIPTIONID,
guidance::RoadClassification(), guidance::RoadClassification(),
util::Coordinate()); util::Coordinate());

48
include/extractor/node_based_edge.hpp
View File

@ -25,27 +25,29 @@ struct NodeBasedEdge
bool roundabout, bool roundabout,
bool circular, bool circular,
bool startpoint, bool startpoint,
TravelMode travel_mode, bool restricted,
bool is_split, bool is_split,
TravelMode travel_mode,
const LaneDescriptionID lane_description_id, const LaneDescriptionID lane_description_id,
guidance::RoadClassification road_classification); guidance::RoadClassification road_classification);
bool operator<(const NodeBasedEdge &other) const; bool operator<(const NodeBasedEdge &other) const;
NodeID source; NodeID source; // 32 4
NodeID target; NodeID target; // 32 4
NodeID name_id; NodeID name_id; // 32 4
EdgeWeight weight; EdgeWeight weight; // 32 4
EdgeWeight duration; EdgeWeight duration; // 32 4
std::uint8_t forward : 1; std::uint8_t forward : 1; // 1
std::uint8_t backward : 1; std::uint8_t backward : 1; // 1
std::uint8_t roundabout : 1; std::uint8_t roundabout : 1; // 1
std::uint8_t circular : 1; std::uint8_t circular : 1; // 1
std::uint8_t startpoint : 1; std::uint8_t startpoint : 1; // 1
std::uint8_t is_split : 1; std::uint8_t restricted : 1; // 1
TravelMode travel_mode : 4; std::uint8_t is_split : 1; // 1
LaneDescriptionID lane_description_id; TravelMode travel_mode : 4; // 4
guidance::RoadClassification road_classification; LaneDescriptionID lane_description_id; // 16 2
guidance::RoadClassification road_classification; // 16 2
}; };
struct NodeBasedEdgeWithOSM : NodeBasedEdge struct NodeBasedEdgeWithOSM : NodeBasedEdge
@ -60,8 +62,9 @@ struct NodeBasedEdgeWithOSM : NodeBasedEdge
bool roundabout, bool roundabout,
bool circular, bool circular,
bool startpoint, bool startpoint,
TravelMode travel_mode, bool restricted,
bool is_split, bool is_split,
TravelMode travel_mode,
const LaneDescriptionID lane_description_id, const LaneDescriptionID lane_description_id,
guidance::RoadClassification road_classification); guidance::RoadClassification road_classification);
@ -74,7 +77,7 @@ struct NodeBasedEdgeWithOSM : NodeBasedEdge
inline NodeBasedEdge::NodeBasedEdge() inline NodeBasedEdge::NodeBasedEdge()
: source(SPECIAL_NODEID), target(SPECIAL_NODEID), name_id(0), weight(0), duration(0), : source(SPECIAL_NODEID), target(SPECIAL_NODEID), name_id(0), weight(0), duration(0),
forward(false), backward(false), roundabout(false), circular(false), startpoint(true), forward(false), backward(false), roundabout(false), circular(false), startpoint(true),
is_split(false), travel_mode(TRAVEL_MODE_INACCESSIBLE), restricted(false), is_split(false), travel_mode(TRAVEL_MODE_INACCESSIBLE),
lane_description_id(INVALID_LANE_DESCRIPTIONID) lane_description_id(INVALID_LANE_DESCRIPTIONID)
{ {
} }
@ -89,13 +92,14 @@ inline NodeBasedEdge::NodeBasedEdge(NodeID source,
bool roundabout, bool roundabout,
bool circular, bool circular,
bool startpoint, bool startpoint,
TravelMode travel_mode, bool restricted,
bool is_split, bool is_split,
TravelMode travel_mode,
const LaneDescriptionID lane_description_id, const LaneDescriptionID lane_description_id,
guidance::RoadClassification road_classification) guidance::RoadClassification road_classification)
: source(source), target(target), name_id(name_id), weight(weight), duration(duration), : source(source), target(target), name_id(name_id), weight(weight), duration(duration),
forward(forward), backward(backward), roundabout(roundabout), circular(circular), forward(forward), backward(backward), roundabout(roundabout), circular(circular),
startpoint(startpoint), is_split(is_split), travel_mode(travel_mode), startpoint(startpoint), restricted(restricted), is_split(is_split), travel_mode(travel_mode),
lane_description_id(lane_description_id), road_classification(std::move(road_classification)) lane_description_id(lane_description_id), road_classification(std::move(road_classification))
{ {
} }
@ -127,8 +131,9 @@ inline NodeBasedEdgeWithOSM::NodeBasedEdgeWithOSM(OSMNodeID source,
bool roundabout, bool roundabout,
bool circular, bool circular,
bool startpoint, bool startpoint,
TravelMode travel_mode, bool restricted,
bool is_split, bool is_split,
TravelMode travel_mode,
const LaneDescriptionID lane_description_id, const LaneDescriptionID lane_description_id,
guidance::RoadClassification road_classification) guidance::RoadClassification road_classification)
: NodeBasedEdge(SPECIAL_NODEID, : NodeBasedEdge(SPECIAL_NODEID,
@ -141,8 +146,9 @@ inline NodeBasedEdgeWithOSM::NodeBasedEdgeWithOSM(OSMNodeID source,
roundabout, roundabout,
circular, circular,
startpoint, startpoint,
travel_mode, restricted,
is_split, is_split,
travel_mode,
lane_description_id, lane_description_id,
std::move(road_classification)), std::move(road_classification)),
osm_source_id(std::move(source)), osm_target_id(std::move(target)) osm_source_id(std::move(source)), osm_target_id(std::move(target))

8
include/util/node_based_graph.hpp
View File

@ -33,11 +33,12 @@ struct NodeBasedEdgeData
bool roundabout, bool roundabout,
bool circular, bool circular,
bool startpoint, bool startpoint,
bool restricted,
extractor::TravelMode travel_mode, extractor::TravelMode travel_mode,
const LaneDescriptionID lane_description_id) const LaneDescriptionID lane_description_id)
: weight(weight), duration(duration), edge_id(edge_id), name_id(name_id), : weight(weight), duration(duration), edge_id(edge_id), name_id(name_id),
reversed(reversed), roundabout(roundabout), circular(circular), startpoint(startpoint), reversed(reversed), roundabout(roundabout), circular(circular), startpoint(startpoint),
travel_mode(travel_mode), lane_description_id(lane_description_id) restricted(restricted), travel_mode(travel_mode), lane_description_id(lane_description_id)
{ {
} }
@ -49,6 +50,7 @@ struct NodeBasedEdgeData
bool roundabout : 1; bool roundabout : 1;
bool circular : 1; bool circular : 1;
bool startpoint : 1; bool startpoint : 1;
bool restricted : 1;
extractor::TravelMode travel_mode : 4; extractor::TravelMode travel_mode : 4;
LaneDescriptionID lane_description_id; LaneDescriptionID lane_description_id;
extractor::guidance::RoadClassification road_classification; extractor::guidance::RoadClassification road_classification;
@ -58,7 +60,8 @@ struct NodeBasedEdgeData
return (reversed == other.reversed) && (roundabout == other.roundabout) && return (reversed == other.reversed) && (roundabout == other.roundabout) &&
(circular == other.circular) && (startpoint == other.startpoint) && (circular == other.circular) && (startpoint == other.startpoint) &&
(travel_mode == other.travel_mode) && (travel_mode == other.travel_mode) &&
(road_classification == other.road_classification); (road_classification == other.road_classification) &&
(restricted == other.restricted);
} }
bool CanCombineWith(const NodeBasedEdgeData &other) const bool CanCombineWith(const NodeBasedEdgeData &other) const
@ -87,6 +90,7 @@ NodeBasedDynamicGraphFromEdges(NodeID number_of_nodes,
output_edge.data.name_id = input_edge.name_id; output_edge.data.name_id = input_edge.name_id;
output_edge.data.travel_mode = input_edge.travel_mode; output_edge.data.travel_mode = input_edge.travel_mode;
output_edge.data.startpoint = input_edge.startpoint; output_edge.data.startpoint = input_edge.startpoint;
output_edge.data.restricted = input_edge.restricted;
output_edge.data.road_classification = input_edge.road_classification; output_edge.data.road_classification = input_edge.road_classification;
output_edge.data.lane_description_id = input_edge.lane_description_id; output_edge.data.lane_description_id = input_edge.lane_description_id;

8
profiles/bicycle.lua
View File

@ -65,6 +65,8 @@ local profile = {
'delivery' 'delivery'
}, },
restricted_access_tag_list = Set { },
access_tags_hierarchy = Sequence { access_tags_hierarchy = Sequence {
'bicycle', 'bicycle',
'vehicle', 'vehicle',
@ -521,4 +523,10 @@ function turn_function(turn)
if turn.has_traffic_light then if turn.has_traffic_light then
turn.duration = turn.duration + profile.traffic_light_penalty turn.duration = turn.duration + profile.traffic_light_penalty
end end
if properties.weight_name == 'cyclability' then
-- penalize turns from non-local access only segments onto local access only tags
if not turn.source_restricted and turn.target_restricted then
turn.weight = turn.weight + 3000
end
end
end end

24
profiles/car.lua
View File

@ -34,6 +34,9 @@ local profile = {
speed_reduction = 0.8, speed_reduction = 0.8,
traffic_light_penalty = 2, traffic_light_penalty = 2,
u_turn_penalty = 20, u_turn_penalty = 20,
restricted_penalty = 3000,
-- Note^: abstract value but in seconds correlates approximately to 50 min
-- meaning that a route through a local access way is > 50 min faster than around
-- Note: this biases right-side driving. -- Note: this biases right-side driving.
-- Should be inverted for left-driving countries. -- Should be inverted for left-driving countries.
@ -63,18 +66,21 @@ local profile = {
'vehicle', 'vehicle',
'permissive', 'permissive',
'designated', 'designated',
'destination', 'hov'
'hov' -- we might filter hov out later depending on the avoid settings or add penalties
}, },
access_tag_blacklist = Set { access_tag_blacklist = Set {
'no', 'no',
'private',
'agricultural', 'agricultural',
'forestry', 'forestry',
'emergency', 'emergency',
'psv', 'psv'
'delivery' },
restricted_access_tag_list = Set {
'private',
'delivery',
'destination'
}, },
access_tags_hierarchy = Sequence { access_tags_hierarchy = Sequence {
@ -331,7 +337,7 @@ function way_function(way, result)
-- handle service road restrictions -- handle service road restrictions
'handle_service', 'handle_service',
-- check high occupancy vehicle restrictions -- handle hov
'handle_hov', 'handle_hov',
-- compute speed taking into account way type, maxspeed tags, etc. -- compute speed taking into account way type, maxspeed tags, etc.
@ -386,5 +392,11 @@ function turn_function (turn)
else else
turn.weight = turn.duration turn.weight = turn.duration
end end
if properties.weight_name == 'routability' then
-- penalize turns from non-local access only segments onto local access only tags
if not turn.source_restricted and turn.target_restricted then
turn.weight = turn.weight + profile.restricted_penalty
end
end
end end
end end

13
profiles/foot.lua
View File

@ -12,6 +12,7 @@ properties.max_speed_for_map_matching = 40/3.6 -- kmph -> m/s
properties.use_turn_restrictions = false properties.use_turn_restrictions = false
properties.continue_straight_at_waypoint = false properties.continue_straight_at_waypoint = false
properties.weight_name = 'duration' properties.weight_name = 'duration'
--properties.weight_name = 'routability'
local walking_speed = 5 local walking_speed = 5
@ -44,12 +45,14 @@ local profile = {
access_tag_blacklist = Set { access_tag_blacklist = Set {
'no', 'no',
'private',
'agricultural', 'agricultural',
'forestry', 'forestry',
'delivery' 'private',
'delivery',
}, },
restricted_access_tag_list = Set { },
access_tags_hierarchy = Sequence { access_tags_hierarchy = Sequence {
'foot', 'foot',
'access' 'access'
@ -244,4 +247,10 @@ function turn_function (turn)
if turn.has_traffic_light then if turn.has_traffic_light then
turn.duration = profile.traffic_light_penalty turn.duration = profile.traffic_light_penalty
end end
if properties.weight_name == 'routability' then
-- penalize turns from non-local access only segments onto local access only tags
if not turn.source_restricted and turn.target_restricted then
turn.weight = turn.weight + 3000
end
end
end end

60
profiles/lib/handlers.lua
View File

@ -177,25 +177,37 @@ function Handlers.handle_hov(way,result,data,profile)
return return
end end
-- in this case we will use penalties instead of filtering out local hov = way:get_value_by_key("hov")
if "designated" == hov then
result.forward_restricted = true
result.backward_restricted = true
end
data.hov_lanes_forward, data.hov_lanes_backward = Tags.get_forward_backward_by_key(way,data,'hov:lanes')
local all_hov_forward = Handlers.has_all_designated_hov_lanes(data.hov_lanes_forward)
local all_hov_backward = Handlers.has_all_designated_hov_lanes(data.hov_lanes_backward)
-- in this case we will use turn penalties instead of filtering out
if properties.weight_name == 'routability' then if properties.weight_name == 'routability' then
if (all_hov_forward) then
result.forward_restricted = true
end
if (all_hov_backward) then
result.backward_restricted = true
end
return return
end end
-- check if all lanes are hov only -- filter out ways where all lanes are hov only
data.hov_lanes_forward, data.hov_lanes_backward = Tags.get_forward_backward_by_key(way,data,'hov:lanes') if all_hov_forward then
local inaccessible_forward = Handlers.has_all_designated_hov_lanes(data.hov_lanes_forward)
local inaccessible_backward = Handlers.has_all_designated_hov_lanes(data.hov_lanes_backward)
if inaccessible_forward then
result.forward_mode = mode.inaccessible result.forward_mode = mode.inaccessible
end end
if inaccessible_backward then if all_hov_backward then
result.backward_mode = mode.inaccessible result.backward_mode = mode.inaccessible
end end
end end
-- check accessibility by traversing our acces tag hierarchy -- check accessibility by traversing our access tag hierarchy
function Handlers.handle_access(way,result,data,profile) function Handlers.handle_access(way,result,data,profile)
data.forward_access, data.backward_access = data.forward_access, data.backward_access =
Tags.get_forward_backward_by_set(way,data,profile.access_tags_hierarchy) Tags.get_forward_backward_by_set(way,data,profile.access_tags_hierarchy)
@ -211,6 +223,14 @@ function Handlers.handle_access(way,result,data,profile)
if result.forward_mode == mode.inaccessible and result.backward_mode == mode.inaccessible then if result.forward_mode == mode.inaccessible and result.backward_mode == mode.inaccessible then
return false return false
end end
if profile.restricted_access_tag_list[data.forward_access] then
result.forward_restricted = true
end
if profile.restricted_access_tag_list[data.backward_access] then
result.backward_restricted = true
end
end end
-- handle speed (excluding maxspeed) -- handle speed (excluding maxspeed)
@ -273,24 +293,6 @@ end
function Handlers.handle_penalties(way,result,data,profile) function Handlers.handle_penalties(way,result,data,profile)
-- heavily penalize a way tagged with all HOV lanes -- heavily penalize a way tagged with all HOV lanes
-- in order to only route over them if there is no other option -- in order to only route over them if there is no other option
local forward_hov_penalty = 1.0
local backward_hov_penalty = 1.0
if profile.avoid.hov_lanes then
local hov = way:get_value_by_key("hov")
if "designated" == hov then
forward_hov_penalty = 0.1
backward_hov_penalty = 0.1
else
data.hov_lanes_forward, data.hov_lanes_backward = Tags.get_forward_backward_by_key(way,data,'hov:lanes')
if Handlers.has_all_designated_hov_lanes(data.hov_lanes_forward) then
forward_hov_penalty = 0.1
end
if Handlers.has_all_designated_hov_lanes(data.hov_lanes_backward) then
backward_hov_penalty = 0.1
end
end
end
local service_penalty = 1.0 local service_penalty = 1.0
local service = way:get_value_by_key("service") local service = way:get_value_by_key("service")
if service and profile.service_penalties[service] then if service and profile.service_penalties[service] then
@ -330,8 +332,8 @@ function Handlers.handle_penalties(way,result,data,profile)
sideroad_penalty = profile.side_road_multiplier sideroad_penalty = profile.side_road_multiplier
end end
local forward_penalty = math.min(service_penalty, width_penalty, alternating_penalty, sideroad_penalty, forward_hov_penalty) local forward_penalty = math.min(service_penalty, width_penalty, alternating_penalty, sideroad_penalty)
local backward_penalty = math.min(service_penalty, width_penalty, alternating_penalty, sideroad_penalty, backward_hov_penalty) local backward_penalty = math.min(service_penalty, width_penalty, alternating_penalty, sideroad_penalty)
if properties.weight_name == 'routability' then if properties.weight_name == 'routability' then
if result.forward_speed > 0 then if result.forward_speed > 0 then

2
src/extractor/edge_based_graph_factory.cpp
View File

@ -526,6 +526,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
// compute weight and duration penalties // compute weight and duration penalties
auto is_traffic_light = m_traffic_lights.count(node_at_center_of_intersection); auto is_traffic_light = m_traffic_lights.count(node_at_center_of_intersection);
ExtractionTurn extracted_turn(turn, is_traffic_light); ExtractionTurn extracted_turn(turn, is_traffic_light);
extracted_turn.source_restricted = edge_data1.restricted;
extracted_turn.target_restricted = edge_data2.restricted;
scripting_environment.ProcessTurn(extracted_turn); scripting_environment.ProcessTurn(extracted_turn);
// turn penalties are limited to [-2^15, 2^15) which roughly // turn penalties are limited to [-2^15, 2^15) which roughly

9
src/extractor/extractor_callbacks.cpp
View File

@ -121,6 +121,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
const auto toValueByEdgeOrByMeter = [&nodes](const double by_way, const double by_meter) { const auto toValueByEdgeOrByMeter = [&nodes](const double by_way, const double by_meter) {
using Value = detail::ByEdgeOrByMeterValue; using Value = detail::ByEdgeOrByMeterValue;
// get value by weight per edge
if (by_way >= 0) if (by_way >= 0)
{ {
// FIXME We divide by the number of edges here, but should rather consider // FIXME We divide by the number of edges here, but should rather consider
@ -132,6 +133,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
} }
else else
{ {
// get value by deriving weight from speed per edge
return Value(Value::by_meter, by_meter); return Value(Value::by_meter, by_meter);
} }
}; };
@ -320,6 +322,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
parsed_way.weight > 0) && parsed_way.weight > 0) &&
(parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE); (parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE);
// split an edge into two edges if forwards/backwards behavior differ
const bool split_edge = in_forward_direction && in_backward_direction && const bool split_edge = in_forward_direction && in_backward_direction &&
((parsed_way.forward_rate != parsed_way.backward_rate) || ((parsed_way.forward_rate != parsed_way.backward_rate) ||
(parsed_way.forward_speed != parsed_way.backward_speed) || (parsed_way.forward_speed != parsed_way.backward_speed) ||
@ -343,8 +346,9 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
parsed_way.roundabout, parsed_way.roundabout,
parsed_way.circular, parsed_way.circular,
parsed_way.is_startpoint, parsed_way.is_startpoint,
parsed_way.forward_travel_mode, parsed_way.forward_restricted,
split_edge, split_edge,
parsed_way.forward_travel_mode,
turn_lane_id_forward, turn_lane_id_forward,
road_classification, road_classification,
{})); {}));
@ -368,8 +372,9 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
parsed_way.roundabout, parsed_way.roundabout,
parsed_way.circular, parsed_way.circular,
parsed_way.is_startpoint, parsed_way.is_startpoint,
parsed_way.backward_travel_mode, parsed_way.backward_restricted,
split_edge, split_edge,
parsed_way.backward_travel_mode,
turn_lane_id_backward, turn_lane_id_backward,
road_classification, road_classification,
{})); {}));

12
src/extractor/scripting_environment_lua.cpp
View File

@ -343,7 +343,11 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
"forward_mode", "forward_mode",
sol::property(&ExtractionWay::get_forward_mode, &ExtractionWay::set_forward_mode), sol::property(&ExtractionWay::get_forward_mode, &ExtractionWay::set_forward_mode),
"backward_mode", "backward_mode",
sol::property(&ExtractionWay::get_backward_mode, &ExtractionWay::set_backward_mode)); sol::property(&ExtractionWay::get_backward_mode, &ExtractionWay::set_backward_mode),
"forward_restricted",
&ExtractionWay::forward_restricted,
"backward_restricted",
&ExtractionWay::backward_restricted);
context.state.new_usertype<ExtractionSegment>("ExtractionSegment", context.state.new_usertype<ExtractionSegment>("ExtractionSegment",
"source", "source",
@ -369,7 +373,11 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
"weight", "weight",
&ExtractionTurn::weight, &ExtractionTurn::weight,
"duration", "duration",
&ExtractionTurn::duration); &ExtractionTurn::duration,
"source_restricted",
&ExtractionTurn::source_restricted,
"target_restricted",
&ExtractionTurn::target_restricted);
// Keep in mind .location is undefined since we're not using libosmium's location cache // Keep in mind .location is undefined since we're not using libosmium's location cache
context.state.new_usertype<osmium::NodeRef>("NodeRef", "id", &osmium::NodeRef::ref); context.state.new_usertype<osmium::NodeRef>("NodeRef", "id", &osmium::NodeRef::ref);

4
unit_tests/extractor/graph_compressor.cpp
View File

@ -22,7 +22,8 @@ namespace
// creates a default edge of unit weight // creates a default edge of unit weight
inline InputEdge MakeUnitEdge(const NodeID from, const NodeID to) inline InputEdge MakeUnitEdge(const NodeID from, const NodeID to)
{ {
// src, tgt, dist, edge_id, name_id, fwd, bkwd, roundabout, circular, travel_mode // src, tgt, dist, edge_id, name_id, fwd, bkwd, roundabout, circular, startpoint, local access,
// split edge, travel_mode
return {from, return {from,
to, to,
1, 1,
@ -32,6 +33,7 @@ inline InputEdge MakeUnitEdge(const NodeID from, const NodeID to)
false, false,
false, false,
false, false,
false,
true, true,
TRAVEL_MODE_INACCESSIBLE, TRAVEL_MODE_INACCESSIBLE,
INVALID_LANE_DESCRIPTIONID}; INVALID_LANE_DESCRIPTIONID};

4
unit_tests/library/tile.cpp
View File

@ -32,7 +32,7 @@ BOOST_AUTO_TEST_CASE(test_tile)
const auto rc = osrm.Tile(params, result); const auto rc = osrm.Tile(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
BOOST_CHECK_EQUAL(result.size(), 113824); BOOST_CHECK(result.size() > 115000);
protozero::pbf_reader tile_message(result); protozero::pbf_reader tile_message(result);
tile_message.next(); tile_message.next();
@ -205,7 +205,7 @@ BOOST_AUTO_TEST_CASE(test_tile)
} }
BOOST_CHECK_EQUAL(number_of_turn_keys, 3); BOOST_CHECK_EQUAL(number_of_turn_keys, 3);
BOOST_CHECK_EQUAL(number_of_turns_found, 732); BOOST_CHECK(number_of_turns_found > 700);
} }
BOOST_AUTO_TEST_CASE(test_tile_turns) BOOST_AUTO_TEST_CASE(test_tile_turns)