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 |
| designated | x |
| no | |
| private | |
| private | x |
| agricultural | |
| forestry | |
| psv | |
| delivery | |
| delivery | x |
| some_tag | x |
| destination | x |
Scenario: Car - Access tags on nodes
@ -134,11 +135,11 @@ Feature: Car - Restricted access
| permissive | x |
| designated | x |
| no | |
| private | |
| private | x |
| agricultural | |
| forestry | |
| psv | |
| delivery | |
| delivery | x |
| some_tag | x |
Scenario: Car - Access tags on both node and way
@ -156,15 +157,15 @@ Feature: Car - Restricted access
Scenario: Car - Access combinations
Then routability should be
| highway | accesss | vehicle | motor_vehicle | motorcar | bothw |
| runway | private | | | permissive | x |
| primary | forestry | | yes | | x |
| cycleway | | | designated | | x |
| residential | | yes | no | | |
| motorway | yes | permissive | | private | |
| trunk | agricultural | designated | permissive | no | |
| pedestrian | | | | | |
| pedestrian | | | | destination | x |
| highway | access | vehicle | motor_vehicle | motorcar | forw | backw | # |
| runway | private | | | permissive | x | x | |
| primary | forestry | | yes | | x | x | |
| cycleway | | | designated | | x | x | |
| residential | | yes | no | | | | |
| motorway | yes | permissive | | private | x | | implied oneway |
| trunk | agricultural | designated | permissive | no | | | |
| pedestrian | | | | | | | |
| pedestrian | | | | destination | x | x | |
Scenario: Car - Ignore access tags for other modes
Then routability should be
@ -182,7 +183,7 @@ Feature: Car - Restricted access
Scenario: Car - designated HOV ways are rated low
Then routability should be
| highway | hov | bothw | forw_rate | backw_rate |
| primary | designated | x | 2 | 2 |
| primary | designated | x | 18 | 18 |
| primary | yes | 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
Then routability should be
| 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 |
@hov
Scenario: Car - a way with all lanes HOV-designated is highly penalized by default (similar to hov=designated)
Then routability should be
| 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 | | | x | x | 18 | 2 |
| primary | designated | | | | x | x | 2 | 18 |
| primary | designated\|designated | designated\|designated | | | x | x | 2 | 2 |
| primary | designated | designated | | | x | x | 18 | 18 |
| primary | | designated | | | x | x | 18 | 18 |
| primary | designated | | | | x | x | 18 | 18 |
| primary | designated\|designated | designated\|designated | | | x | x | 18 | 18 |
| primary | designated\|no | designated\|no | | | x | x | 18 | 18 |
| primary | yes\|no | yes\|no | | | x | x | 18 | 18 |
| primary | | | | | x | x | 18 | 18 |
| primary | designated | | | -1 | | x | | 18 |
| primary | | designated | | -1 | | x | | 2 |
| primary | | | designated | yes | x | | 2 | |
| primary | | | designated | -1 | | x | | 2 |
| primary | | designated | | -1 | | x | | 18 |
| primary | | | designated | yes | x | | 18 | |
| primary | | | designated | -1 | | x | | 18 |
| primary | | | designated\| | yes | x | | 18 | |
| primary | | | designated\| | -1 | | x | | 18 |
| primary | | | designated\|designated | yes | x | | 2 | |
| primary | | | designated\|designated | -1 | | x | | 2 |
| primary | | | designated\|designated | yes | x | | 18 | |
| primary | | | designated\|designated | -1 | | x | | 18 |
| primary | | | designated\|yes | yes | x | | 18 | |
| primary | | | designated\|no | -1 | | x | | 18 |
@ -250,7 +251,7 @@ Feature: Car - Restricted access
| gate | yes | x |
| gate | permissive | x |
| gate | designated | x |
| gate | private | |
| gate | private | x |
| gate | garbagetag | x |
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 | designated | x |
| gate | no | |
| gate | private | |
| gate | private | x |
| gate | agricultural | |
| wall | | |
| wall | yes | x |
| wall | permissive | x |
| wall | designated | x |
| wall | no | |
| wall | private | |
| wall | private | x |
| wall | agricultural | |
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
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 |
| motorway | | | | | x | |
| motorway | no | grade1 | excellent | asphalt | | |
| motorway | private | grade1 | excellent | asphalt | | |
| motorway | private | grade1 | excellent | asphalt | x | |
| motorway | agricultural | grade1 | excellent | asphalt | | |
| motorway | forestry | grade1 | excellent | asphalt | | |
| motorway | emergency | grade1 | excellent | asphalt | | |
| primary | | | | | x | x |
| primary | private | grade1 | excellent | asphalt | x | x |
| primary | no | grade1 | excellent | asphalt | | |
| primary | private | grade1 | excellent | asphalt | | |
| primary | agricultural | grade1 | excellent | asphalt | | |
| primary | forestry | 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)
: angle(180. - turn.angle), turn_type(turn.instruction.type),
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;
double weight;
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_backward.clear();
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,
@ -106,6 +108,8 @@ struct ExtractionWay
bool roundabout;
bool circular;
bool is_startpoint;
bool backward_restricted;
bool forward_restricted;
TravelMode forward_travel_mode : 4;
TravelMode backward_travel_mode : 4;
guidance::RoadClassification road_classification;

15
include/extractor/internal_extractor_edge.hpp
View File

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

48
include/extractor/node_based_edge.hpp
View File

@ -25,27 +25,29 @@ struct NodeBasedEdge
bool roundabout,
bool circular,
bool startpoint,
TravelMode travel_mode,
bool restricted,
bool is_split,
TravelMode travel_mode,
const LaneDescriptionID lane_description_id,
guidance::RoadClassification road_classification);
bool operator<(const NodeBasedEdge &other) const;
NodeID source;
NodeID target;
NodeID name_id;
EdgeWeight weight;
EdgeWeight duration;
std::uint8_t forward : 1;
std::uint8_t backward : 1;
std::uint8_t roundabout : 1;
std::uint8_t circular : 1;
std::uint8_t startpoint : 1;
std::uint8_t is_split : 1;
TravelMode travel_mode : 4;
LaneDescriptionID lane_description_id;
guidance::RoadClassification road_classification;
NodeID source; // 32 4
NodeID target; // 32 4
NodeID name_id; // 32 4
EdgeWeight weight; // 32 4
EdgeWeight duration; // 32 4
std::uint8_t forward : 1; // 1
std::uint8_t backward : 1; // 1
std::uint8_t roundabout : 1; // 1
std::uint8_t circular : 1; // 1
std::uint8_t startpoint : 1; // 1
std::uint8_t restricted : 1; // 1
std::uint8_t is_split : 1; // 1
TravelMode travel_mode : 4; // 4
LaneDescriptionID lane_description_id; // 16 2
guidance::RoadClassification road_classification; // 16 2
};
struct NodeBasedEdgeWithOSM : NodeBasedEdge
@ -60,8 +62,9 @@ struct NodeBasedEdgeWithOSM : NodeBasedEdge
bool roundabout,
bool circular,
bool startpoint,
TravelMode travel_mode,
bool restricted,
bool is_split,
TravelMode travel_mode,
const LaneDescriptionID lane_description_id,
guidance::RoadClassification road_classification);
@ -74,7 +77,7 @@ struct NodeBasedEdgeWithOSM : NodeBasedEdge
inline NodeBasedEdge::NodeBasedEdge()
: source(SPECIAL_NODEID), target(SPECIAL_NODEID), name_id(0), weight(0), duration(0),
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)
{
}
@ -89,13 +92,14 @@ inline NodeBasedEdge::NodeBasedEdge(NodeID source,
bool roundabout,
bool circular,
bool startpoint,
TravelMode travel_mode,
bool restricted,
bool is_split,
TravelMode travel_mode,
const LaneDescriptionID lane_description_id,
guidance::RoadClassification road_classification)
: source(source), target(target), name_id(name_id), weight(weight), duration(duration),
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))
{
}
@ -127,8 +131,9 @@ inline NodeBasedEdgeWithOSM::NodeBasedEdgeWithOSM(OSMNodeID source,
bool roundabout,
bool circular,
bool startpoint,
TravelMode travel_mode,
bool restricted,
bool is_split,
TravelMode travel_mode,
const LaneDescriptionID lane_description_id,
guidance::RoadClassification road_classification)
: NodeBasedEdge(SPECIAL_NODEID,
@ -141,8 +146,9 @@ inline NodeBasedEdgeWithOSM::NodeBasedEdgeWithOSM(OSMNodeID source,
roundabout,
circular,
startpoint,
travel_mode,
restricted,
is_split,
travel_mode,
lane_description_id,
std::move(road_classification)),
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 circular,
bool startpoint,
bool restricted,
extractor::TravelMode travel_mode,
const LaneDescriptionID lane_description_id)
: weight(weight), duration(duration), edge_id(edge_id), name_id(name_id),
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 circular : 1;
bool startpoint : 1;
bool restricted : 1;
extractor::TravelMode travel_mode : 4;
LaneDescriptionID lane_description_id;
extractor::guidance::RoadClassification road_classification;
@ -58,7 +60,8 @@ struct NodeBasedEdgeData
return (reversed == other.reversed) && (roundabout == other.roundabout) &&
(circular == other.circular) && (startpoint == other.startpoint) &&
(travel_mode == other.travel_mode) &&
(road_classification == other.road_classification);
(road_classification == other.road_classification) &&
(restricted == other.restricted);
}
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.travel_mode = input_edge.travel_mode;
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.lane_description_id = input_edge.lane_description_id;

8
profiles/bicycle.lua
View File

@ -65,6 +65,8 @@ local profile = {
'delivery'
},
restricted_access_tag_list = Set { },
access_tags_hierarchy = Sequence {
'bicycle',
'vehicle',
@ -521,4 +523,10 @@ function turn_function(turn)
if turn.has_traffic_light then
turn.duration = turn.duration + profile.traffic_light_penalty
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

24
profiles/car.lua
View File

@ -34,6 +34,9 @@ local profile = {
speed_reduction = 0.8,
traffic_light_penalty = 2,
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.
-- Should be inverted for left-driving countries.
@ -63,18 +66,21 @@ local profile = {
'vehicle',
'permissive',
'designated',
'destination',
'hov' -- we might filter hov out later depending on the avoid settings or add penalties
'hov'
},
access_tag_blacklist = Set {
'no',
'private',
'agricultural',
'forestry',
'emergency',
'psv',
'delivery'
'psv'
},
restricted_access_tag_list = Set {
'private',
'delivery',
'destination'
},
access_tags_hierarchy = Sequence {
@ -331,7 +337,7 @@ function way_function(way, result)
-- handle service road restrictions
'handle_service',
-- check high occupancy vehicle restrictions
-- handle hov
'handle_hov',
-- compute speed taking into account way type, maxspeed tags, etc.
@ -386,5 +392,11 @@ function turn_function (turn)
else
turn.weight = turn.duration
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

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.continue_straight_at_waypoint = false
properties.weight_name = 'duration'
--properties.weight_name = 'routability'
local walking_speed = 5
@ -44,12 +45,14 @@ local profile = {
access_tag_blacklist = Set {
'no',
'private',
'agricultural',
'forestry',
'delivery'
'private',
'delivery',
},
restricted_access_tag_list = Set { },
access_tags_hierarchy = Sequence {
'foot',
'access'
@ -244,4 +247,10 @@ function turn_function (turn)
if turn.has_traffic_light then
turn.duration = profile.traffic_light_penalty
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

60
profiles/lib/handlers.lua
View File

@ -177,25 +177,37 @@ function Handlers.handle_hov(way,result,data,profile)
return
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 (all_hov_forward) then
result.forward_restricted = true
end
if (all_hov_backward) then
result.backward_restricted = true
end
return
end
-- check if all lanes are hov only
data.hov_lanes_forward, data.hov_lanes_backward = Tags.get_forward_backward_by_key(way,data,'hov:lanes')
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
-- filter out ways where all lanes are hov only
if all_hov_forward then
result.forward_mode = mode.inaccessible
end
if inaccessible_backward then
if all_hov_backward then
result.backward_mode = mode.inaccessible
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)
data.forward_access, data.backward_access =
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
return false
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
-- handle speed (excluding maxspeed)
@ -273,24 +293,6 @@ end
function Handlers.handle_penalties(way,result,data,profile)
-- heavily penalize a way tagged with all HOV lanes
-- 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 = way:get_value_by_key("service")
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
end
local forward_penalty = math.min(service_penalty, width_penalty, alternating_penalty, sideroad_penalty, forward_hov_penalty)
local backward_penalty = math.min(service_penalty, width_penalty, alternating_penalty, sideroad_penalty, backward_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)
if properties.weight_name == 'routability' 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
auto is_traffic_light = m_traffic_lights.count(node_at_center_of_intersection);
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);
// 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) {
using Value = detail::ByEdgeOrByMeterValue;
// get value by weight per edge
if (by_way >= 0)
{
// 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
{
// get value by deriving weight from speed per edge
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.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 &&
((parsed_way.forward_rate != parsed_way.backward_rate) ||
(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.circular,
parsed_way.is_startpoint,
parsed_way.forward_travel_mode,
parsed_way.forward_restricted,
split_edge,
parsed_way.forward_travel_mode,
turn_lane_id_forward,
road_classification,
{}));
@ -368,8 +372,9 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
parsed_way.roundabout,
parsed_way.circular,
parsed_way.is_startpoint,
parsed_way.backward_travel_mode,
parsed_way.backward_restricted,
split_edge,
parsed_way.backward_travel_mode,
turn_lane_id_backward,
road_classification,
{}));

12
src/extractor/scripting_environment_lua.cpp
View File

@ -343,7 +343,11 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
"forward_mode",
sol::property(&ExtractionWay::get_forward_mode, &ExtractionWay::set_forward_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",
"source",
@ -369,7 +373,11 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
"weight",
&ExtractionTurn::weight,
"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
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
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,
to,
1,
@ -32,6 +33,7 @@ inline InputEdge MakeUnitEdge(const NodeID from, const NodeID to)
false,
false,
false,
false,
true,
TRAVEL_MODE_INACCESSIBLE,
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);
BOOST_CHECK(rc == Status::Ok);
BOOST_CHECK_EQUAL(result.size(), 113824);
BOOST_CHECK(result.size() > 115000);
protozero::pbf_reader tile_message(result);
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_turns_found, 732);
BOOST_CHECK(number_of_turns_found > 700);
}
BOOST_AUTO_TEST_CASE(test_tile_turns)