diff --git a/profiles/countrycar.lua b/profiles/countrycar.lua deleted file mode 100644 index cb7598b65..000000000 --- a/profiles/countrycar.lua +++ /dev/null @@ -1,527 +0,0 @@ --- Car profile - -api_version = 4 - -Set = require('lib/set') -Sequence = require('lib/sequence') -Handlers = require("lib/way_handlers") -Relations = require("lib/relations") -TrafficSignal = require("lib/traffic_signal") -find_access_tag = require("lib/access").find_access_tag -country_speeds = require("lib/country_speeds") -limit = require("lib/maxspeed").limit -Utils = require("lib/utils") -Measure = require("lib/measure") - -function setup() - return { - properties = { - max_speed_for_map_matching = 180/3.6, -- 180kmph -> m/s - -- For routing based on duration, but weighted for preferring certain roads - weight_name = 'routability', - -- For shortest duration without penalties for accessibility - -- weight_name = 'duration', - -- For shortest distance without penalties for accessibility - -- weight_name = 'distance', - process_call_tagless_node = false, - u_turn_penalty = 20, - continue_straight_at_waypoint = true, - use_turn_restrictions = true, - left_hand_driving = false, - traffic_light_penalty = 2, - }, - - profile = 'vehicle', - default_mode = mode.driving, - default_speed = 10, - oneway_handling = true, - side_road_multiplier = 0.8, - turn_penalty = 7.5, - speed_reduction = 0.8, - turn_bias = 1.075, - cardinal_directions = false, - - -- Size of the vehicle, to be limited by physical restriction of the way - vehicle_height = 2.0, -- in meters, 2.0m is the height slightly above biggest SUVs - vehicle_width = 1.9, -- in meters, ways with narrow tag are considered narrower than 2.2m - - -- Size of the vehicle, to be limited mostly by legal restriction of the way - vehicle_length = 4.8, -- in meters, 4.8m is the length of large or family car - vehicle_weight = 2000, -- in kilograms - - -- a list of suffixes to suppress in name change instructions. The suffixes also include common substrings of each other - suffix_list = { - 'N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW', 'North', 'South', 'West', 'East', 'Nor', 'Sou', 'We', 'Ea' - }, - - barrier_whitelist = Set { - 'cattle_grid', - 'border_control', - 'toll_booth', - 'sally_port', - 'gate', - 'lift_gate', - 'no', - 'entrance', - 'height_restrictor', - 'arch' - }, - - access_tag_whitelist = Set { - 'yes', - 'motorcar', - 'motor_vehicle', - 'vehicle', - 'permissive', - 'designated', - 'hov' - }, - - access_tag_blacklist = Set { - 'no', - 'agricultural', - 'forestry', - 'emergency', - 'psv', - 'customers', - 'private', - 'delivery', - 'destination' - }, - - -- tags disallow access to in combination with highway=service - service_access_tag_blacklist = Set { - 'private' - }, - - restricted_access_tag_list = Set { - 'private', - 'delivery', - 'destination', - 'customers', - }, - - access_tags_hierarchy = Sequence { - 'motorcar', - 'motor_vehicle', - 'vehicle', - 'access' - }, - - service_tag_forbidden = Set { - 'emergency_access' - }, - - restrictions = Sequence { - 'motorcar', - 'motor_vehicle', - 'vehicle' - }, - - classes = Sequence { - 'toll', 'motorway', 'ferry', 'restricted', 'tunnel' - }, - - -- classes to support for exclude flags - excludable = Sequence { - Set {'toll'}, - Set {'motorway'}, - Set {'ferry'} - }, - - avoid = Set { - 'area', - -- 'toll', -- uncomment this to avoid tolls - 'reversible', - 'impassable', - 'hov_lanes', - 'steps', - 'construction', - 'proposed' - }, - - hwyspeeds = Sequence { - highway = { - motorway = 90, - motorway_link = 45, - trunk = 85, - trunk_link = 40, - primary = 65, - primary_link = 30, - secondary = 55, - secondary_link = 25, - tertiary = 40, - tertiary_link = 20, - unclassified = 25, - residential = 25, - living_street = 10, - service = 15 - } - }, - - service_penalties = { - alley = 0.5, - parking = 0.5, - parking_aisle = 0.5, - driveway = 0.5, - ["drive-through"] = 0.5, - ["drive-thru"] = 0.5 - }, - - restricted_highway_whitelist = Set { - 'motorway', - 'motorway_link', - 'trunk', - 'trunk_link', - 'primary', - 'primary_link', - 'secondary', - 'secondary_link', - 'tertiary', - 'tertiary_link', - 'residential', - 'living_street', - 'unclassified', - 'service' - }, - - construction_whitelist = Set { - 'no', - 'widening', - 'minor', - }, - - route_speeds = { - ferry = 5, - shuttle_train = 10 - }, - - bridge_speeds = { - movable = 5 - }, - - -- surface/trackype/smoothness - -- values were estimated from looking at the photos at the relevant wiki pages - - -- max speed for surfaces - surface_speeds = { - asphalt = nil, -- nil mean no limit. removing the line has the same effect - concrete = nil, - ["concrete:plates"] = nil, - ["concrete:lanes"] = nil, - paved = nil, - - cement = 80, - compacted = 80, - fine_gravel = 80, - - paving_stones = 60, - metal = 60, - bricks = 60, - - grass = 40, - wood = 40, - sett = 40, - grass_paver = 40, - gravel = 40, - unpaved = 40, - ground = 40, - dirt = 40, - pebblestone = 40, - tartan = 40, - - cobblestone = 30, - clay = 30, - - earth = 20, - stone = 20, - rocky = 20, - sand = 20, - - mud = 10 - }, - - -- max speed for tracktypes - tracktype_speeds = { - grade1 = 60, - grade2 = 40, - grade3 = 30, - grade4 = 25, - grade5 = 20 - }, - - -- max speed for smoothnesses - smoothness_speeds = { - intermediate = 80, - bad = 40, - very_bad = 20, - horrible = 10, - very_horrible = 5, - impassable = 0 - }, - - -- http://wiki.openstreetmap.org/wiki/Speed_limits - maxspeed_table_default = { - urban = 50, - rural = 90, - trunk = 110, - motorway = 130 - }, - - -- List only exceptions - maxspeed_table = { - ["at:rural"] = 100, - ["at:trunk"] = 100, - ["be:motorway"] = 120, - ["be-bru:rural"] = 70, - ["be-bru:urban"] = 30, - ["be-vlg:rural"] = 70, - ["bg:motorway"] = 140, - ["by:urban"] = 60, - ["by:motorway"] = 110, - ["ca-on:rural"] = 80, - ["ch:rural"] = 80, - ["ch:trunk"] = 100, - ["ch:motorway"] = 120, - ["cz:trunk"] = 0, - ["cz:motorway"] = 0, - ["de:living_street"] = 7, - ["de:rural"] = 100, - ["de:motorway"] = 0, - ["dk:rural"] = 80, - ["es:trunk"] = 90, - ["fr:rural"] = 80, - ["gb:nsl_single"] = (60*1609)/1000, - ["gb:nsl_dual"] = (70*1609)/1000, - ["gb:motorway"] = (70*1609)/1000, - ["nl:rural"] = 80, - ["nl:trunk"] = 100, - ['no:rural'] = 80, - ['no:motorway'] = 110, - ['ph:urban'] = 40, - ['ph:rural'] = 80, - ['ph:motorway'] = 100, - ['pl:rural'] = 100, - ['pl:trunk'] = 120, - ['pl:motorway'] = 140, - ["ro:trunk"] = 100, - ["ru:living_street"] = 20, - ["ru:urban"] = 60, - ["ru:motorway"] = 110, - ["uk:nsl_single"] = (60*1609)/1000, - ["uk:nsl_dual"] = (70*1609)/1000, - ["uk:motorway"] = (70*1609)/1000, - ['za:urban'] = 60, - ['za:rural'] = 100, - ["none"] = 140 - }, - - relation_types = Sequence { - "route" - }, - - -- classify highway tags when necessary for turn weights - highway_turn_classification = { - }, - - -- classify access tags when necessary for turn weights - access_turn_classification = { - }, - - uselocationtags = Set - { - 'countryspeeds', - } - - } -end - -function process_node(profile, node, result, relations) - -- parse access and barrier tags - local access = find_access_tag(node, profile.access_tags_hierarchy) - if access then - if profile.access_tag_blacklist[access] and not profile.restricted_access_tag_list[access] then - result.barrier = true - end - else - local barrier = node:get_value_by_key("barrier") - if barrier then - -- check height restriction barriers - local restricted_by_height = false - if barrier == 'height_restrictor' then - local maxheight = Measure.get_max_height(node:get_value_by_key("maxheight"), node) - restricted_by_height = maxheight and maxheight < profile.vehicle_height - end - - -- make an exception for rising bollard barriers - local bollard = node:get_value_by_key("bollard") - local rising_bollard = bollard and "rising" == bollard - - -- make an exception for lowered/flat barrier=kerb - -- and incorrect tagging of highway crossing kerb as highway barrier - local kerb = node:get_value_by_key("kerb") - local highway = node:get_value_by_key("highway") - local flat_kerb = kerb and ("lowered" == kerb or "flush" == kerb) - local highway_crossing_kerb = barrier == "kerb" and highway and highway == "crossing" - - if not profile.barrier_whitelist[barrier] - and not rising_bollard - and not flat_kerb - and not highway_crossing_kerb - or restricted_by_height then - result.barrier = true - end - end - end - - -- check if node is a traffic light - result.traffic_lights = TrafficSignal.get_value(node) -end - -function process_way(profile, way, result, relations) - -- the intial filtering of ways based on presence of tags - -- affects processing times significantly, because all ways - -- have to be checked. - -- to increase performance, prefetching and intial tag check - -- is done in directly instead of via a handler. - - -- in general we should try to abort as soon as - -- possible if the way is not routable, to avoid doing - -- unnecessary work. this implies we should check things that - -- commonly forbids access early, and handle edge cases later. - - -- data table for storing intermediate values during processing - local data = { - -- prefetch tags - highway = way:get_value_by_key('highway'), - bridge = way:get_value_by_key('bridge'), - route = way:get_value_by_key('route') - } - - -- perform an quick initial check and abort if the way is - -- obviously not routable. - -- highway or route tags must be in data table, bridge is optional - if (not data.highway or data.highway == '') and - (not data.route or data.route == '') - then - return - end - - if profile.uselocationtags and profile.uselocationtags.countryspeeds then - data.location = country_speeds.getcountrytag(way) - end - - handlers = Sequence { - -- set the default mode for this profile. if can be changed later - -- in case it turns we're e.g. on a ferry - WayHandlers.default_mode, - - -- check various tags that could indicate that the way is not - -- routable. this includes things like status=impassable, - -- toll=yes and oneway=reversible - WayHandlers.blocked_ways, - WayHandlers.avoid_ways, - WayHandlers.handle_height, - WayHandlers.handle_width, - WayHandlers.handle_length, - WayHandlers.handle_weight, - - -- determine access status by checking our hierarchy of - -- access tags, e.g: motorcar, motor_vehicle, vehicle - WayHandlers.access, - - -- check whether forward/backward directions are routable - WayHandlers.oneway, - - -- check a road's destination - WayHandlers.destinations, - - -- check whether we're using a special transport mode - WayHandlers.ferries, - WayHandlers.movables, - - -- handle service road restrictions - WayHandlers.service, - - -- handle hov - WayHandlers.hov, - - -- compute speed taking into account way type, maxspeed tags, etc. - country_speeds.wayspeed, - WayHandlers.maxspeed, - WayHandlers.surface, - WayHandlers.penalties, - - -- compute class labels - WayHandlers.classes, - - -- handle turn lanes and road classification, used for guidance - WayHandlers.turn_lanes, - WayHandlers.classification, - - -- handle various other flags - WayHandlers.roundabouts, - WayHandlers.startpoint, - WayHandlers.driving_side, - - -- set name, ref and pronunciation - WayHandlers.names, - - -- set weight properties of the way - WayHandlers.weights, - - -- set classification of ways relevant for turns - WayHandlers.way_classification_for_turn - } - - WayHandlers.run(profile, way, result, data, handlers, relations) - - if profile.cardinal_directions then - Relations.process_way_refs(way, relations, result) - end -end - -function process_turn(profile, turn) - -- Use a sigmoid function to return a penalty that maxes out at turn_penalty - -- over the space of 0-180 degrees. Values here were chosen by fitting - -- the function to some turn penalty samples from real driving. - local turn_penalty = profile.turn_penalty - local turn_bias = turn.is_left_hand_driving and 1. / profile.turn_bias or profile.turn_bias - - if turn.has_traffic_light then - turn.duration = profile.properties.traffic_light_penalty - end - - if turn.number_of_roads > 2 or turn.source_mode ~= turn.target_mode or turn.is_u_turn then - if turn.angle >= 0 then - turn.duration = turn.duration + turn_penalty / (1 + math.exp( -((13 / turn_bias) * turn.angle/180 - 6.5*turn_bias))) - else - turn.duration = turn.duration + turn_penalty / (1 + math.exp( -((13 * turn_bias) * -turn.angle/180 - 6.5/turn_bias))) - end - - if turn.is_u_turn then - turn.duration = turn.duration + profile.properties.u_turn_penalty - end - end - - -- for distance based routing we don't want to have penalties based on turn angle - if profile.properties.weight_name == 'distance' then - turn.weight = 0 - else - turn.weight = turn.duration - end - - if profile.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 = constants.max_turn_weight - end - end -end - -return { - setup = setup, - process_way = process_way, - process_node = process_node, - process_turn = process_turn -}