lua: refactor car.lua into smaller functions
This commit is contained in:
Emil Tin
Patrick Niklaus
parent
cff69178e8
commit
ce04a608b8
478
profiles/car.lua
478
profiles/car.lua
@ -235,40 +235,20 @@ function node_function (node, result)
|
||||
end
|
||||
end
|
||||
|
||||
-- abort early if this way is obviouslt not routable
|
||||
function should_abort_early(data)
|
||||
return TagCache.get(data,'highway') == nil and
|
||||
TagCache.get(data,'route') == nil and
|
||||
TagCache.get(data,'bridge') == nil
|
||||
end
|
||||
|
||||
function way_function(way, result)
|
||||
local data = {
|
||||
way = way,
|
||||
cache = {},
|
||||
}
|
||||
|
||||
local route = TagCache.get(data,"route")
|
||||
local bridge = TagCache.get(data,"bridge")
|
||||
|
||||
if should_abort_early(data) then
|
||||
return
|
||||
end
|
||||
|
||||
-- default to driving mode, may get overwritten below
|
||||
result.forward_mode = mode.driving
|
||||
result.backward_mode = mode.driving
|
||||
|
||||
-- we dont route over areas
|
||||
local area = TagCache.get(data,"area")
|
||||
if ignore_areas and area and "yes" == area then
|
||||
return
|
||||
end
|
||||
|
||||
-- handle high occupancy vehicle tags
|
||||
function handle_hov(data)
|
||||
-- respect user-preference for HOV-only ways
|
||||
if ignore_hov_ways then
|
||||
local hov = TagCache.get(data,"hov")
|
||||
if hov and "designated" == hov then
|
||||
return
|
||||
return false
|
||||
end
|
||||
|
||||
-- also respect user-preference for HOV-only ways when all lanes are HOV-designated
|
||||
@ -304,26 +284,53 @@ function way_function(way, result)
|
||||
|
||||
if hov_all_designated or hov_all_designated_forward then
|
||||
if reverse then
|
||||
result.backward_mode = mode.inaccessible
|
||||
data.result.backward_mode = mode.inaccessible
|
||||
else
|
||||
result.forward_mode = mode.inaccessible
|
||||
data.result.forward_mode = mode.inaccessible
|
||||
end
|
||||
end
|
||||
|
||||
if hov_all_designated_backward then
|
||||
if reverse then
|
||||
result.forward_mode = mode.inaccessible
|
||||
data.result.forward_mode = mode.inaccessible
|
||||
else
|
||||
result.backward_mode = mode.inaccessible
|
||||
data.result.backward_mode = mode.inaccessible
|
||||
end
|
||||
end
|
||||
|
||||
end -- hov handling
|
||||
end
|
||||
end
|
||||
|
||||
-- handle squares and other areas
|
||||
function handle_area(data)
|
||||
-- we dont route over areas
|
||||
local area = TagCache.get(data,"area")
|
||||
if ignore_areas and area and "yes" == area then
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
-- handle toll roads
|
||||
function handle_toll(data)
|
||||
-- respect user-preference for toll=yes ways
|
||||
local toll = TagCache.get(data,"toll")
|
||||
if ignore_toll_ways and toll and "yes" == toll then
|
||||
return
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
-- handle various that can block access
|
||||
function handle_blocking(data)
|
||||
if handle_area(data) == false then
|
||||
return false
|
||||
end
|
||||
|
||||
if handle_hov(data) == false then
|
||||
return false
|
||||
end
|
||||
|
||||
if handle_toll(data) == false then
|
||||
return false
|
||||
end
|
||||
|
||||
-- Reversible oneways change direction with low frequency (think twice a day):
|
||||
@ -331,246 +338,218 @@ function way_function(way, result)
|
||||
-- Note: alternating (high frequency) oneways are handled below with penalty.
|
||||
local oneway = TagCache.get(data,"oneway")
|
||||
if oneway and "reversible" == oneway then
|
||||
return
|
||||
return false
|
||||
end
|
||||
|
||||
local impassable = TagCache.get(data,"impassable")
|
||||
if impassable and "yes" == impassable then
|
||||
return
|
||||
return false
|
||||
end
|
||||
|
||||
local status = TagCache.get(data,"status")
|
||||
if status and "impassable" == status then
|
||||
return
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
-- Check if we are allowed to access the way
|
||||
local access = find_access_tag(way, access_tags_hierarchy)
|
||||
if access_tag_blacklist[access] then
|
||||
return
|
||||
-- set default mode
|
||||
function handle_default_mode(data)
|
||||
data.result.forward_mode = mode.driving
|
||||
data.result.backward_mode = mode.driving
|
||||
end
|
||||
|
||||
-- check accessibility by traversing our acces tag hierarchy
|
||||
function handle_access(data)
|
||||
data.access = find_access_tag(data.way, access_tags_hierarchy)
|
||||
if access_tag_blacklist[data.access] then
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
-- handling ferries and piers
|
||||
-- handling ferries and piers
|
||||
function handle_ferries(data)
|
||||
local route = TagCache.get(data,"route")
|
||||
local route_speed = speed_profile[route]
|
||||
if (route_speed and route_speed > 0) then
|
||||
TagCache.set(data,"highway",route)
|
||||
local duration = TagCache.get(data,"duration")
|
||||
if duration and durationIsValid(duration) then
|
||||
result.duration = max( parseDuration(duration), 1 )
|
||||
end
|
||||
result.forward_mode = mode.ferry
|
||||
result.backward_mode = mode.ferry
|
||||
result.forward_speed = route_speed
|
||||
result.backward_speed = route_speed
|
||||
TagCache.set(data,"highway",route)
|
||||
local duration = TagCache.get(data,"duration")
|
||||
if duration and durationIsValid(duration) then
|
||||
data.result.duration = max( parseDuration(duration), 1 )
|
||||
end
|
||||
data.result.forward_mode = mode.ferry
|
||||
data.result.backward_mode = mode.ferry
|
||||
data.result.forward_speed = route_speed
|
||||
data.result.backward_speed = route_speed
|
||||
end
|
||||
end
|
||||
|
||||
-- handling movable bridges
|
||||
-- handling movable bridges
|
||||
function handle_movables(data)
|
||||
local bridge = TagCache.get(data,"bridge")
|
||||
local bridge_speed = speed_profile[bridge]
|
||||
local capacity_car = TagCache.get(data,"capacity:car")
|
||||
if (bridge_speed and bridge_speed > 0) and (capacity_car ~= 0) then
|
||||
TagCache.set(data,"highway",bridge)
|
||||
local duration = TagCache.get(data,"duration")
|
||||
if duration and durationIsValid(duration) then
|
||||
result.duration = max( parseDuration(duration), 1 )
|
||||
data.result.duration = max( parseDuration(duration), 1 )
|
||||
end
|
||||
result.forward_speed = bridge_speed
|
||||
result.backward_speed = bridge_speed
|
||||
data.result.forward_speed = bridge_speed
|
||||
data.result.backward_speed = bridge_speed
|
||||
end
|
||||
end
|
||||
|
||||
-- leave early if this way is not accessible
|
||||
if "" == TagCache.get(data,"highway") then
|
||||
return
|
||||
end
|
||||
|
||||
if result.forward_speed == -1 then
|
||||
-- handle speed (excluding maxspeed)
|
||||
function handle_speed(data)
|
||||
if data.result.forward_speed == -1 then
|
||||
local highway_speed = speed_profile[TagCache.get(data,"highway")]
|
||||
local max_speed = parse_maxspeed( TagCache.get(data,"maxspeed") )
|
||||
-- Set the avg speed on the way if it is accessible by road class
|
||||
if highway_speed then
|
||||
if max_speed and max_speed > highway_speed then
|
||||
result.forward_speed = max_speed
|
||||
result.backward_speed = max_speed
|
||||
data.result.forward_speed = max_speed
|
||||
data.result.backward_speed = max_speed
|
||||
-- max_speed = math.huge
|
||||
else
|
||||
result.forward_speed = highway_speed
|
||||
result.backward_speed = highway_speed
|
||||
data.result.forward_speed = highway_speed
|
||||
data.result.backward_speed = highway_speed
|
||||
end
|
||||
else
|
||||
-- Set the avg speed on ways that are marked accessible
|
||||
if access_tag_whitelist[access] then
|
||||
result.forward_speed = speed_profile["default"]
|
||||
result.backward_speed = speed_profile["default"]
|
||||
if access_tag_whitelist[data.access] then
|
||||
data.result.forward_speed = speed_profile["default"]
|
||||
data.result.backward_speed = speed_profile["default"]
|
||||
end
|
||||
end
|
||||
if 0 == max_speed then
|
||||
max_speed = math.huge
|
||||
end
|
||||
result.forward_speed = min(result.forward_speed, max_speed)
|
||||
result.backward_speed = min(result.backward_speed, max_speed)
|
||||
data.result.forward_speed = min(data.result.forward_speed, max_speed)
|
||||
data.result.backward_speed = min(data.result.backward_speed, max_speed)
|
||||
end
|
||||
|
||||
if -1 == result.forward_speed and -1 == result.backward_speed then
|
||||
return
|
||||
if -1 == data.result.forward_speed and -1 == data.result.backward_speed then
|
||||
return false
|
||||
end
|
||||
|
||||
if handle_side_roads(data) == false then
|
||||
return false
|
||||
end
|
||||
|
||||
-- reduce speed on special side roads
|
||||
if handle_surface(data) == false then
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
-- reduce speed on special side roads
|
||||
function handle_side_roads(data)
|
||||
local sideway = TagCache.get(data,"side_road")
|
||||
if "yes" == sideway or
|
||||
"rotary" == sideway then
|
||||
result.forward_speed = result.forward_speed * side_road_speed_multiplier
|
||||
result.backward_speed = result.backward_speed * side_road_speed_multiplier
|
||||
data.result.forward_speed = data.result.forward_speed * side_road_speed_multiplier
|
||||
data.result.backward_speed = data.result.backward_speed * side_road_speed_multiplier
|
||||
end
|
||||
end
|
||||
|
||||
-- reduce speed on bad surfaces
|
||||
-- reduce speed on bad surfaces
|
||||
function handle_surface(data)
|
||||
local surface = TagCache.get(data,"surface")
|
||||
local tracktype = TagCache.get(data,"tracktype")
|
||||
local smoothness = TagCache.get(data,"smoothness")
|
||||
|
||||
if surface and surface_speeds[surface] then
|
||||
result.forward_speed = math.min(surface_speeds[surface], result.forward_speed)
|
||||
result.backward_speed = math.min(surface_speeds[surface], result.backward_speed)
|
||||
data.result.forward_speed = math.min(surface_speeds[surface], data.result.forward_speed)
|
||||
data.result.backward_speed = math.min(surface_speeds[surface], data.result.backward_speed)
|
||||
end
|
||||
if tracktype and tracktype_speeds[tracktype] then
|
||||
result.forward_speed = math.min(tracktype_speeds[tracktype], result.forward_speed)
|
||||
result.backward_speed = math.min(tracktype_speeds[tracktype], result.backward_speed)
|
||||
data.result.forward_speed = math.min(tracktype_speeds[tracktype], data.result.forward_speed)
|
||||
data.result.backward_speed = math.min(tracktype_speeds[tracktype], data.result.backward_speed)
|
||||
end
|
||||
if smoothness and smoothness_speeds[smoothness] then
|
||||
result.forward_speed = math.min(smoothness_speeds[smoothness], result.forward_speed)
|
||||
result.backward_speed = math.min(smoothness_speeds[smoothness], result.backward_speed)
|
||||
data.result.forward_speed = math.min(smoothness_speeds[smoothness], data.result.forward_speed)
|
||||
data.result.backward_speed = math.min(smoothness_speeds[smoothness], data.result.backward_speed)
|
||||
end
|
||||
end
|
||||
|
||||
-- set the road classification based on guidance globals configuration
|
||||
set_classification(TagCache.get(data,"highway"),result,way)
|
||||
|
||||
-- handles name, including ref and pronunciation
|
||||
function handle_names(data)
|
||||
-- parse the remaining tags
|
||||
local name = TagCache.get(data,"name")
|
||||
local pronunciation = TagCache.get(data,"name:pronunciation")
|
||||
local ref = TagCache.get(data,"ref")
|
||||
local junction = TagCache.get(data,"junction")
|
||||
-- local barrier = TagCache.get(data,"barrier", "")
|
||||
-- local cycleway = TagCache.get(data,"cycleway", "")
|
||||
local service = TagCache.get(data,"service")
|
||||
|
||||
-- Set the name that will be used for instructions
|
||||
local has_ref = ref and "" ~= ref
|
||||
local has_name = name and "" ~= name
|
||||
local has_pronunciation = pronunciation and "" ~= pronunciation
|
||||
|
||||
if has_name then
|
||||
result.name = name
|
||||
if name then
|
||||
data.result.name = name
|
||||
end
|
||||
|
||||
if has_ref then
|
||||
result.ref = canonicalizeStringList(ref, ";")
|
||||
if ref then
|
||||
data.result.ref = canonicalizeStringList(ref, ";")
|
||||
end
|
||||
|
||||
if has_pronunciation then
|
||||
result.pronunciation = pronunciation
|
||||
if pronunciation then
|
||||
data.result.pronunciation = pronunciation
|
||||
end
|
||||
end
|
||||
|
||||
-- handle turn lanes
|
||||
function handle_turn_lanes(data)
|
||||
local turn_lanes = ""
|
||||
local turn_lanes_forward = ""
|
||||
local turn_lanes_backward = ""
|
||||
|
||||
turn_lanes, turn_lanes_forward, turn_lanes_backward = get_turn_lanes(way)
|
||||
if turn_lanes and turn_lanes ~= "" then
|
||||
result.turn_lanes_forward = turn_lanes;
|
||||
result.turn_lanes_backward = turn_lanes;
|
||||
turn_lanes, turn_lanes_forward, turn_lanes_backward = get_turn_lanes(data.way)
|
||||
if turn_lanes and turn_lanes ~= "" then
|
||||
data.result.turn_lanes_forward = turn_lanes;
|
||||
data.result.turn_lanes_backward = turn_lanes;
|
||||
else
|
||||
if turn_lanes_forward and turn_lanes_forward ~= "" then
|
||||
result.turn_lanes_forward = turn_lanes_forward;
|
||||
data.result.turn_lanes_forward = turn_lanes_forward;
|
||||
end
|
||||
|
||||
if turn_lanes_backward and turn_lanes_backward ~= "" then
|
||||
result.turn_lanes_backward = turn_lanes_backward;
|
||||
data.result.turn_lanes_backward = turn_lanes_backward;
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
if junction and "roundabout" == junction then
|
||||
result.roundabout = true
|
||||
-- junctions
|
||||
function handle_junctions(data)
|
||||
if TagCache.get(data,"junction") == "roundabout" then
|
||||
data.result.roundabout = true
|
||||
end
|
||||
end
|
||||
|
||||
-- Set access restriction flag if access is allowed under certain restrictions only
|
||||
if access ~= "" and access_tag_restricted[access] then
|
||||
result.is_access_restricted = true
|
||||
-- Set access restriction flag if access is allowed under certain restrictions only
|
||||
function handle_restricted(data)
|
||||
if data.access ~= "" and access_tag_restricted[data.access] then
|
||||
data.result.is_access_restricted = true
|
||||
end
|
||||
end
|
||||
|
||||
if service and service ~= "" then
|
||||
-- service roads
|
||||
function handle_service(data)
|
||||
local service = TagCache.get(data,"service")
|
||||
if service then
|
||||
-- Set access restriction flag if service is allowed under certain restrictions only
|
||||
if service_tag_restricted[service] then
|
||||
result.is_access_restricted = true
|
||||
data.result.is_access_restricted = true
|
||||
end
|
||||
|
||||
-- Set don't allow access to certain service roads
|
||||
if service_tag_forbidden[service] then
|
||||
result.forward_mode = mode.inaccessible
|
||||
result.backward_mode = mode.inaccessible
|
||||
return
|
||||
data.result.forward_mode = mode.inaccessible
|
||||
data.result.backward_mode = mode.inaccessible
|
||||
return false
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- Set direction according to tags on way
|
||||
if obey_oneway then
|
||||
if oneway == "-1" then
|
||||
result.forward_mode = mode.inaccessible
|
||||
|
||||
local is_forward = false
|
||||
local destination = get_destination(way, is_forward)
|
||||
result.destinations = canonicalizeStringList(destination, ",")
|
||||
elseif oneway == "yes" or
|
||||
oneway == "1" or
|
||||
oneway == "true" or
|
||||
junction == "roundabout" or
|
||||
(TagCache.get(data,"highway") == "motorway" and oneway ~= "no") then
|
||||
|
||||
result.backward_mode = mode.inaccessible
|
||||
|
||||
local is_forward = true
|
||||
local destination = get_destination(way, is_forward)
|
||||
result.destinations = canonicalizeStringList(destination, ",")
|
||||
end
|
||||
end
|
||||
|
||||
-- Override speed settings if explicit forward/backward maxspeeds are given
|
||||
local maxspeed_forward = parse_maxspeed(TagCache.get(data,"maxspeed:forward"))
|
||||
local maxspeed_backward = parse_maxspeed(TagCache.get(data,"maxspeed:backward"))
|
||||
if maxspeed_forward and maxspeed_forward > 0 then
|
||||
if mode.inaccessible ~= result.forward_mode and mode.inaccessible ~= result.backward_mode then
|
||||
result.backward_speed = result.forward_speed
|
||||
end
|
||||
result.forward_speed = maxspeed_forward
|
||||
end
|
||||
if maxspeed_backward and maxspeed_backward > 0 then
|
||||
result.backward_speed = maxspeed_backward
|
||||
end
|
||||
|
||||
-- Override speed settings if advisory forward/backward maxspeeds are given
|
||||
local advisory_speed = parse_maxspeed(TagCache.get(data,"maxspeed:advisory"))
|
||||
local advisory_forward = parse_maxspeed(TagCache.get(data,"maxspeed:advisory:forward"))
|
||||
local advisory_backward = parse_maxspeed(TagCache.get(data,"maxspeed:advisory:backward"))
|
||||
-- apply bi-directional advisory speed first
|
||||
if advisory_speed and advisory_speed > 0 then
|
||||
if mode.inaccessible ~= result.forward_mode then
|
||||
result.forward_speed = advisory_speed
|
||||
end
|
||||
if mode.inaccessible ~= result.backward_mode then
|
||||
result.backward_speed = advisory_speed
|
||||
end
|
||||
end
|
||||
if advisory_forward and advisory_forward > 0 then
|
||||
if mode.inaccessible ~= result.forward_mode and mode.inaccessible ~= result.backward_mode then
|
||||
result.backward_speed = result.forward_speed
|
||||
end
|
||||
result.forward_speed = advisory_forward
|
||||
end
|
||||
if advisory_backward and advisory_backward > 0 then
|
||||
result.backward_speed = advisory_backward
|
||||
end
|
||||
|
||||
-- scale speeds to get better average driving times
|
||||
function handle_speed_scaling(data)
|
||||
local width = math.huge
|
||||
local lanes = math.huge
|
||||
if result.forward_speed > 0 or result.backward_speed > 0 then
|
||||
if data.result.forward_speed > 0 or data.result.backward_speed > 0 then
|
||||
local width_string = TagCache.get(data,"width")
|
||||
if width_string and tonumber(width_string:match("%d*")) then
|
||||
width = tonumber(width_string:match("%d*"))
|
||||
@ -582,45 +561,166 @@ function way_function(way, result)
|
||||
end
|
||||
end
|
||||
|
||||
local is_bidirectional = result.forward_mode ~= mode.inaccessible and result.backward_mode ~= mode.inaccessible
|
||||
local is_bidirectional = data.result.forward_mode ~= mode.inaccessible and
|
||||
data.result.backward_mode ~= mode.inaccessible
|
||||
|
||||
-- scale speeds to get better avg driving times
|
||||
if result.forward_speed > 0 then
|
||||
local scaled_speed = result.forward_speed * speed_reduction
|
||||
local service = TagCache.get(data,"service")
|
||||
if data.result.forward_speed > 0 then
|
||||
local scaled_speed = data.result.forward_speed * speed_reduction
|
||||
local penalized_speed = math.huge
|
||||
if service and service ~= "" and service_speeds[service] then
|
||||
penalized_speed = service_speeds[service]
|
||||
elseif width <= 3 or (lanes <= 1 and is_bidirectional) then
|
||||
penalized_speed = result.forward_speed / 2
|
||||
penalized_speed = data.result.forward_speed / 2
|
||||
end
|
||||
result.forward_speed = math.min(penalized_speed, scaled_speed)
|
||||
data.result.forward_speed = math.min(penalized_speed, scaled_speed)
|
||||
end
|
||||
|
||||
if result.backward_speed > 0 then
|
||||
local scaled_speed = result.backward_speed * speed_reduction
|
||||
if data.result.backward_speed > 0 then
|
||||
local scaled_speed = data.result.backward_speed * speed_reduction
|
||||
local penalized_speed = math.huge
|
||||
if service and service ~= "" and service_speeds[service]then
|
||||
penalized_speed = service_speeds[service]
|
||||
elseif width <= 3 or (lanes <= 1 and is_bidirectional) then
|
||||
penalized_speed = result.backward_speed / 2
|
||||
penalized_speed = data.result.backward_speed / 2
|
||||
end
|
||||
result.backward_speed = math.min(penalized_speed, scaled_speed)
|
||||
data.result.backward_speed = math.min(penalized_speed, scaled_speed)
|
||||
end
|
||||
end
|
||||
|
||||
-- oneways
|
||||
function handle_oneway(data)
|
||||
local oneway = TagCache.get(data,"oneway")
|
||||
if obey_oneway then
|
||||
if oneway == "-1" then
|
||||
data.result.forward_mode = mode.inaccessible
|
||||
|
||||
local is_forward = false
|
||||
local destination = get_destination(data.way, is_forward)
|
||||
data.result.destinations = canonicalizeStringList(destination, ",")
|
||||
elseif oneway == "yes" or
|
||||
oneway == "1" or
|
||||
oneway == "true" or
|
||||
TagCache.get(data,"junction") == "roundabout" or
|
||||
(TagCache.get(data,"highway") == "motorway" and oneway ~= "no") then
|
||||
|
||||
data.result.backward_mode = mode.inaccessible
|
||||
|
||||
local is_forward = true
|
||||
local destination = get_destination(data.way, is_forward)
|
||||
data.result.destinations = canonicalizeStringList(destination, ",")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- maxspeed and advisory maxspeed
|
||||
function handle_maxspeed(data)
|
||||
-- Override speed settings if explicit forward/backward maxspeeds are given
|
||||
local maxspeed_forward = parse_maxspeed(TagCache.get(data,"maxspeed:forward"))
|
||||
local maxspeed_backward = parse_maxspeed(TagCache.get(data,"maxspeed:backward"))
|
||||
if maxspeed_forward and maxspeed_forward > 0 then
|
||||
if mode.inaccessible ~= data.result.forward_mode and
|
||||
mode.inaccessible ~= data.result.backward_mode then
|
||||
data.result.backward_speed = data.result.forward_speed
|
||||
end
|
||||
data.result.forward_speed = maxspeed_forward
|
||||
end
|
||||
if maxspeed_backward and maxspeed_backward > 0 then
|
||||
data.result.backward_speed = maxspeed_backward
|
||||
end
|
||||
|
||||
-- Handle high frequency reversible oneways (think traffic signal controlled, changing direction every 15 minutes).
|
||||
-- Scaling speed to take average waiting time into account plus some more for start / stop.
|
||||
if oneway and "alternating" == oneway then
|
||||
-- Override speed settings if advisory forward/backward maxspeeds are given
|
||||
local advisory_speed = parse_maxspeed(TagCache.get(data,"maxspeed:advisory"))
|
||||
local advisory_forward = parse_maxspeed(TagCache.get(data,"maxspeed:advisory:forward"))
|
||||
local advisory_backward = parse_maxspeed(TagCache.get(data,"maxspeed:advisory:backward"))
|
||||
-- apply bi-directional advisory speed first
|
||||
if advisory_speed and advisory_speed > 0 then
|
||||
if mode.inaccessible ~= data.result.forward_mode then
|
||||
data.result.forward_speed = advisory_speed
|
||||
end
|
||||
if mode.inaccessible ~= data.result.backward_mode then
|
||||
data.result.backward_speed = advisory_speed
|
||||
end
|
||||
end
|
||||
if advisory_forward and advisory_forward > 0 then
|
||||
if mode.inaccessible ~= data.result.forward_mode and mode.inaccessible ~= data.result.backward_mode then
|
||||
data.result.backward_speed = data.result.forward_speed
|
||||
end
|
||||
data.result.forward_speed = advisory_forward
|
||||
end
|
||||
if advisory_backward and advisory_backward > 0 then
|
||||
data.result.backward_speed = advisory_backward
|
||||
end
|
||||
end
|
||||
|
||||
-- Handle high frequency reversible oneways (think traffic signal controlled, changing direction every 15 minutes).
|
||||
-- Scaling speed to take average waiting time into account plus some more for start / stop.
|
||||
function handle_alternating(data)
|
||||
if "alternating" == TagCache.get(data,'oneway') then
|
||||
local scaling_factor = 0.4
|
||||
if result.forward_speed ~= math.huge then
|
||||
result.forward_speed = result.forward_speed * scaling_factor
|
||||
if data.result.forward_speed ~= math.huge then
|
||||
data.result.forward_speed = data.result.forward_speed * scaling_factor
|
||||
end
|
||||
if result.backward_speed ~= math.huge then
|
||||
result.backward_speed = result.backward_speed * scaling_factor
|
||||
if data.result.backward_speed ~= math.huge then
|
||||
data.result.backward_speed = data.result.backward_speed * scaling_factor
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- determine if this way can be used as a start/end point for routing
|
||||
function handle_startpoint(data)
|
||||
-- only allow this road as start point if it not a ferry
|
||||
result.is_startpoint = result.forward_mode == mode.driving or result.backward_mode == mode.driving
|
||||
data.result.is_startpoint = data.result.forward_mode == mode.driving or
|
||||
data.result.backward_mode == mode.driving
|
||||
end
|
||||
|
||||
-- main entry point for processsing a way
|
||||
function way_function(way, result)
|
||||
|
||||
-- define a table that we can pass around to helper functions
|
||||
-- so they have access to the input/output objects.
|
||||
|
||||
-- we also use a table as a local cache of tags, to avoid calling
|
||||
-- into C++ more than once for each tag, without having to
|
||||
-- pass lists of already fetches tags around.
|
||||
|
||||
local data = {
|
||||
way = way,
|
||||
result = result,
|
||||
cache = {},
|
||||
}
|
||||
|
||||
-- perform each procesing step sequentially.
|
||||
-- most steps can abort processing, meaning the way
|
||||
-- is not routable
|
||||
|
||||
if should_abort_early(data) then return end
|
||||
handle_default_mode(data)
|
||||
if handle_blocking(data) == false then return end
|
||||
if handle_access(data) == false then return end
|
||||
if handle_ferries(data) == false then return end
|
||||
if handle_movables(data) == false then return end
|
||||
|
||||
-- leave early if this way is not accessible
|
||||
if "" == TagCache.get(data,"highway") then return end
|
||||
|
||||
if handle_speed(data) == false then return end
|
||||
|
||||
-- set the road classification based on guidance globals configuration
|
||||
set_classification(TagCache.get(data,"highway"),result,way)
|
||||
|
||||
handle_names(data)
|
||||
handle_turn_lanes(data)
|
||||
handle_junctions(data)
|
||||
handle_restricted(data)
|
||||
|
||||
if handle_service(data) == false then return end
|
||||
if handle_oneway(data) == false then return end
|
||||
if handle_maxspeed(data) == false then return end
|
||||
|
||||
handle_speed_scaling(data)
|
||||
handle_alternating(data)
|
||||
handle_startpoint(data)
|
||||
end
|
||||
|
||||
function turn_function (angle)
|
||||
|
||||
@ -1,9 +1,6 @@
|
||||
-- Enable calling our lua profile code directly, which makes it easier to debug.
|
||||
-- We simulate the normal C++ environment by defining some globals and functions.
|
||||
-- FIXME:
|
||||
-- There are a few C++ tag helper methods that LUA code can call.
|
||||
-- Debugging LUA code thay uses these will not work unless we reimplement the
|
||||
-- methods in LUA.
|
||||
-- Enable calling our lua profile code directly from the lua command line,
|
||||
-- which makes it easier to debug.
|
||||
-- We simulate the normal C++ environment by defining the required globals and functions.
|
||||
|
||||
-- Usage:
|
||||
-- > cd profiles
|
||||
@ -13,7 +10,6 @@
|
||||
-- for more convenient printing of tables
|
||||
local pprint = require('lib/pprint')
|
||||
|
||||
|
||||
-- globals that are normally set from C++
|
||||
|
||||
-- profiles code modifies this table
|
||||
@ -47,13 +43,43 @@ mode = {
|
||||
|
||||
-- input tags, normally extracted from OSM data
|
||||
local way = {
|
||||
highway = 'primary'
|
||||
highway = 'primary',
|
||||
name = 'Main Street',
|
||||
--width = '3',
|
||||
--maxspeed = '30',
|
||||
--['maxspeed:advisory'] = '25',
|
||||
--oneway = '-1',
|
||||
--service = 'alley',
|
||||
--['oneway:bicycle'] = 'yes',
|
||||
--junction = 'roundabout',
|
||||
--['name:pronunciation'] = 'fuerloong',
|
||||
--route = 'ferry',
|
||||
--duration = '00:01:00',
|
||||
--hov = 'designated',
|
||||
--access = 'no'
|
||||
}
|
||||
-- function normally provided via C++
|
||||
-- tag function normally provided via C++
|
||||
function way:get_value_by_key(k)
|
||||
return self[k]
|
||||
end
|
||||
|
||||
-- Mock C++ helper functions which are called from LUA.
|
||||
-- FIXME
|
||||
-- Debugging LUA code that uses these will not work correctly
|
||||
-- unless we reimplement themethods in LUA.
|
||||
|
||||
function durationIsValid(str)
|
||||
return true
|
||||
end
|
||||
|
||||
function parseDuration(str)
|
||||
return 1
|
||||
end
|
||||
|
||||
function canonicalizeStringList(str)
|
||||
return str
|
||||
end
|
||||
|
||||
-- start state of result table, normally set form C++
|
||||
local result = {
|
||||
road_classification = {},
|
||||
|
||||
Loading…
Reference in New Issue
Block a user