ottbike.lua

-- Bicycle profile

api_version = 2

Set = require('lib/set')
Sequence = require('lib/sequence')
Handlers = require("lib/way_handlers")
find_access_tag = require("lib/access").find_access_tag
limit = require("lib/maxspeed").limit

function setup()
  local default_speed = 20
  local walking_speed = 6

  return {
    properties = {
      u_turn_penalty                = 20,
      traffic_light_penalty         = 5,
      weight_name                   = 'cyclability',
      --weight_name                   = 'duration',
      process_call_tagless_node     = false,
      max_speed_for_map_matching    = 50/3.6, -- kmph -> m/s
      use_turn_restrictions         = false,
      continue_straight_at_waypoint = false
    },

    default_mode              = mode.cycling,
    default_speed             = default_speed,
    walking_speed             = walking_speed,
    oneway_handling           = true,
    turn_penalty              = 6,
    turn_bias                 = 1.4,
    use_public_transport      = true,

    allowed_start_modes = Set {
      mode.cycling,
      mode.pushing_bike
    },

    barrier_whitelist = Set {
      'sump_buster',
      'bus_trap',
      'cycle_barrier',
      'bollard',
      'entrance',
      'cattle_grid',
      'border_control',
      'toll_booth',
      'sally_port',
      'gate',
      'lift_gate',
      'no',
      'block'
    },

    access_tag_whitelist = Set {
      'yes',
      'permissive',
      'designated'
    },

    access_tag_blacklist = Set {
      'no',
      'private',
      'agricultural',
      'forestry',
      'delivery'
    },

    restricted_access_tag_list = Set { },

    restricted_highway_whitelist = Set { },

    construction_whitelist = Set {
      'no',
      'widening',
      'minor',
    },

    access_tags_hierarchy = Sequence {
      'bicycle',
      'vehicle',
      'access'
    },

    restrictions = Set {
      'bicycle'
    },

    cycleway_tags = Set {
      'track',
      'lane',
      'opposite',
      'opposite_lane',
      'opposite_track',
      'share_busway',
      'sharrow',
      'shared',
      'shared_lane'
    },

    -- reduce the driving speed by 30% for unsafe roads
    -- only used for cyclability metric
    unsafe_highway_list = {
      trunk = 0.6,
      primary = 0.7,
      secondary = 0.75,
      tertiary = 0.8,
      trunk_link = 0.6,
      primary_link = 0.7,
      secondary_link = 0.75,
      tertiary_link = 0.8,
      cycleway = 1.2
    },

    service_penalties = {
      parking_aisle             = 0.7,
    },

    bicycle_speeds = {
      cycleway = default_speed,
      primary = default_speed,
      primary_link = default_speed,
      secondary = default_speed,
      secondary_link = default_speed,
      tertiary = default_speed,
      tertiary_link = default_speed,
      trunk = default_speed,
      trunk_link = default_speed,
      residential = default_speed,
      unclassified = default_speed,
      living_street = default_speed,
      road = default_speed,
      service = default_speed,
      track = 12,
      footway = default_speed*0.75,
      path = default_speed
    },

    pedestrian_speeds = {
      pedestrian = walking_speed,
      steps = 1
    },

    railway_speeds = {
      train = 10,
      railway = 10,
      subway = 10,
      light_rail = 10,
      monorail = 10,
      tram = 10
    },

    platform_speeds = {
      platform = walking_speed
    },

    amenity_speeds = {
      parking = 10,
      parking_entrance = 10
    },

    man_made_speeds = {
      pier = walking_speed
    },

    route_speeds = {
      ferry = 5
    },

    bridge_speeds = {
      movable = 5
    },

    surface_speeds = {
      asphalt = default_speed,
      paved = default_speed,
      fine_gravel = default_speed,
      paving_stones = 15,
      ["cobblestone:flattened"] = 15,
      compacted = 15,
      concrete = 12,
      unpaved = 10,
      gravel = 10,
      pebblestone = 6,
      cobblestone = 6,
      ground = 10,
      dirt = 10,
      earth = 6,
      grass = 6,
      mud = 3,
      sand = 3,
      sett = 10
    },

    tracktype_speeds = {
    },

    smoothness_speeds = {
      intermediate = default_speed * 0.9,
      bad = default_speed * 0.75,
      very_bad = default_speed * 0.7,
      horrible = default_speed * 0.65,
      very_horrible = default_speed * 0.6
    },

    avoid = Set {
      'impassable',
      'construction'
    }
  }
end

local function parse_maxspeed(source)
    if not source then
        return 0
    end
    local n = tonumber(source:match("%d*"))
    if not n then
        n = 0
    end
    if string.match(source, "mph") or string.match(source, "mp/h") then
        n = (n*1609)/1000
    end
    return n
end

function process_node(profile, node, result)
  -- parse access and barrier tags
  local highway = node:get_value_by_key("highway")
  local is_crossing = highway and highway == "crossing"

  local access = find_access_tag(node, profile.access_tags_hierarchy)
  if access and access ~= "" then
    -- access restrictions on crossing nodes are not relevant for
    -- the traffic on the road
    if profile.access_tag_blacklist[access] and not is_crossing then
      result.barrier = true
    end
  else
    local barrier = node:get_value_by_key("barrier")
    if barrier and "" ~= barrier then
      if not profile.barrier_whitelist[barrier] then
        result.barrier = true
      end
    end
  end

  -- check if node is a traffic light
  local tag = node:get_value_by_key("highway")
  if tag and "traffic_signals" == tag then
    result.traffic_lights = true
  end
end

function handle_bicycle_tags(profile,way,result,data)
    -- initial routability check, filters out buildings, boundaries, etc
  local route = way:get_value_by_key("route")
  local man_made = way:get_value_by_key("man_made")
  local railway = way:get_value_by_key("railway")
  local amenity = way:get_value_by_key("amenity")
  local public_transport = way:get_value_by_key("public_transport")
  local bridge = way:get_value_by_key("bridge")

  if (not data.highway or data.highway == '') and
  (not route or route == '') and
  (not profile.use_public_transport or not railway or railway=='') and
  (not amenity or amenity=='') and
  (not man_made or man_made=='') and
  (not public_transport or public_transport=='') and
  (not bridge or bridge=='')
  then
    return false
  end

  -- access
  local access = find_access_tag(way, profile.access_tags_hierarchy)
  if access and profile.access_tag_blacklist[access] then
    return false
  end

  -- other tags
  local junction = way:get_value_by_key("junction")
  local maxspeed = parse_maxspeed(way:get_value_by_key ( "maxspeed") )
  local maxspeed_forward = parse_maxspeed(way:get_value_by_key( "maxspeed:forward"))
  local maxspeed_backward = parse_maxspeed(way:get_value_by_key( "maxspeed:backward"))
  local barrier = way:get_value_by_key("barrier")
  local oneway = way:get_value_by_key("oneway")
  local oneway_bicycle = way:get_value_by_key("oneway:bicycle")
  local cycleway = way:get_value_by_key("cycleway")
  local cycleway_left = way:get_value_by_key("cycleway:left")
  local cycleway_right = way:get_value_by_key("cycleway:right")
  local duration = way:get_value_by_key("duration")
  local service = way:get_value_by_key("service")
  local foot = way:get_value_by_key("foot")
  local foot_forward = way:get_value_by_key("foot:forward")
  local foot_backward = way:get_value_by_key("foot:backward")
  local bicycle = way:get_value_by_key("bicycle")


  local way_type_allows_pushing = false

  -- speed
  local bridge_speed = profile.bridge_speeds[bridge]
  if (bridge_speed and bridge_speed > 0) then
    data.highway = bridge
    if duration and durationIsValid(duration) then
      result.duration = math.max( parseDuration(duration), 1 )
    end
    result.forward_speed = bridge_speed
    result.backward_speed = bridge_speed
    way_type_allows_pushing = true
  elseif profile.route_speeds[route] then
    -- ferries (doesn't cover routes tagged using relations)
    result.forward_mode = mode.ferry
    result.backward_mode = mode.ferry
    if duration and durationIsValid(duration) then
      result.duration = math.max( 1, parseDuration(duration) )
    else
       result.forward_speed = profile.route_speeds[route]
       result.backward_speed = profile.route_speeds[route]
    end
  -- railway platforms (old tagging scheme)
  elseif railway and profile.platform_speeds[railway] then
    result.forward_speed = profile.platform_speeds[railway]
    result.backward_speed = profile.platform_speeds[railway]
    way_type_allows_pushing = true
  -- public_transport platforms (new tagging platform)
  elseif public_transport and profile.platform_speeds[public_transport] then
    result.forward_speed = profile.platform_speeds[public_transport]
    result.backward_speed = profile.platform_speeds[public_transport]
    way_type_allows_pushing = true
  -- railways
  elseif profile.use_public_transport and railway and profile.railway_speeds[railway] and profile.access_tag_whitelist[access] then
    result.forward_mode = mode.train
    result.backward_mode = mode.train
    result.forward_speed = profile.railway_speeds[railway]
    result.backward_speed = profile.railway_speeds[railway]
  elseif amenity and profile.amenity_speeds[amenity] then
    -- parking areas
    result.forward_speed = profile.amenity_speeds[amenity]
    result.backward_speed = profile.amenity_speeds[amenity]
    way_type_allows_pushing = true
  elseif profile.bicycle_speeds[data.highway] then
    -- regular ways
    result.forward_speed = profile.bicycle_speeds[data.highway]
    result.backward_speed = profile.bicycle_speeds[data.highway]
    way_type_allows_pushing = true
  elseif access and profile.access_tag_whitelist[access]  then
    -- unknown way, but valid access tag
    result.forward_speed = profile.default_speed
    result.backward_speed = profile.default_speed
    way_type_allows_pushing = true
  end

  -- oneway
  local implied_oneway = junction == "roundabout" or junction == "circular" or data.highway == "motorway"
  local reverse = false

  if oneway_bicycle == "yes" or oneway_bicycle == "1" or oneway_bicycle == "true" then
    result.backward_mode = mode.inaccessible
  elseif oneway_bicycle == "no" or oneway_bicycle == "0" or oneway_bicycle == "false" then
   -- prevent other cases
  elseif oneway_bicycle == "-1" then
    result.forward_mode = mode.inaccessible
    reverse = true
  elseif oneway == "yes" or oneway == "1" or oneway == "true" then
    result.backward_mode = mode.inaccessible
  elseif oneway == "no" or oneway == "0" or oneway == "false" then
    -- prevent other cases
  elseif oneway == "-1" then
    result.forward_mode = mode.inaccessible
    reverse = true
  elseif implied_oneway then
    result.backward_mode = mode.inaccessible
  end

  -- cycleway
  local has_cycleway_left = false
  local has_cycleway_right = false

  if cycleway_left and profile.cycleway_tags[cycleway_left] then
    has_cycleway_left = true
  end
  if cycleway_right and profile.cycleway_tags[cycleway_right] then
    has_cycleway_right = true
  end
  if cycleway and string.find(cycleway, "opposite") == 1 then
    if reverse then
      has_cycleway_right = true
  else
      has_cycleway_left = true
    end
  elseif cycleway and profile.cycleway_tags[cycleway] then
    -- "cycleway" tag without left/right should not affect a direction
    -- already forbidden by oneway tags
    has_cycleway_left = result.backward_mode ~= mode.inaccessible
    has_cycleway_right = result.forward_mode ~= mode.inaccessible
  end


  if has_cycleway_left then
    result.backward_mode = mode.cycling
    result.backward_speed = profile.bicycle_speeds["cycleway"]
  end

  if has_cycleway_right then
    result.forward_mode = mode.cycling
    result.forward_speed = profile.bicycle_speeds["cycleway"]
  end

  -- pushing bikes - if no other mode found
  if result.forward_mode == mode.inaccessible or result.backward_mode == mode.inaccessible or
    result.forward_speed == -1 or result.backward_speed == -1 then
    if foot ~= 'no' then
      local push_forward_speed = nil
      local push_backward_speed = nil

      if profile.pedestrian_speeds[data.highway] then
        push_forward_speed = profile.pedestrian_speeds[data.highway]
        push_backward_speed = profile.pedestrian_speeds[data.highway]
      elseif man_made and profile.man_made_speeds[man_made] then
        push_forward_speed = profile.man_made_speeds[man_made]
        push_backward_speed = profile.man_made_speeds[man_made]
      else
        if foot == 'yes' then
          push_forward_speed = profile.walking_speed
          if not implied_oneway then
            push_backward_speed = profile.walking_speed
          end
        elseif foot_forward == 'yes' then
          push_forward_speed = profile.walking_speed
        elseif foot_backward == 'yes' then
          push_backward_speed = profile.walking_speed
        elseif way_type_allows_pushing then
          push_forward_speed = profile.walking_speed
          if not implied_oneway then
            push_backward_speed = profile.walking_speed
          end
        end
      end

      if push_forward_speed and (result.forward_mode == mode.inaccessible or result.forward_speed == -1) then
        result.forward_mode = mode.pushing_bike
        result.forward_speed = push_forward_speed
      end
      if push_backward_speed and (result.backward_mode == mode.inaccessible or result.backward_speed == -1)then
        result.backward_mode = mode.pushing_bike
        result.backward_speed = push_backward_speed
      end

    end

  end


  -- dismount
  if bicycle == "dismount" then
    result.forward_mode = mode.pushing_bike
    result.backward_mode = mode.pushing_bike
    result.forward_speed = profile.walking_speed
    result.backward_speed = profile.walking_speed
  end

  -- reduce speed on bad surfaces
 local surface = way:get_value_by_key("surface")
 local tracktype = way:get_value_by_key("tracktype")
 local smoothness = way:get_value_by_key("smoothness")

 if surface and profile.surface_speeds[surface] then
   result.forward_speed = math.min(profile.surface_speeds[surface], result.forward_speed)
   result.backward_speed = math.min(profile.surface_speeds[surface], result.backward_speed)
 end
 if tracktype and profile.tracktype_speeds[tracktype] then
   result.forward_speed = math.min(profile.tracktype_speeds[tracktype], result.forward_speed)
   result.backward_speed = math.min(profile.tracktype_speeds[tracktype], result.backward_speed)
 end
 if smoothness and profile.smoothness_speeds[smoothness] then
   result.forward_speed = math.min(profile.smoothness_speeds[smoothness], result.forward_speed)
   result.backward_speed = math.min(profile.smoothness_speeds[smoothness], result.backward_speed)
 end

  -- maxspeed
  limit( result, maxspeed, maxspeed_forward, maxspeed_backward )


  -- not routable if no speed assigned
  -- this avoid assertions in debug builds
  if result.forward_speed <= 0 and result.duration <= 0 then
    result.forward_mode = mode.inaccessible
  end
  if result.backward_speed <= 0 and result.duration <= 0 then
    result.backward_mode = mode.inaccessible
  end


  -- convert duration into cyclability
  if profile.properties.weight_name == 'cyclability' then
      local safety_penalty = profile.unsafe_highway_list[data.highway] or 1.
      local is_unsafe = safety_penalty < 1
      local forward_is_unsafe = is_unsafe and not has_cycleway_right
      local backward_is_unsafe = is_unsafe and not has_cycleway_left
      local is_undesireable = data.highway == "service" and profile.service_penalties[service]
      local forward_penalty = 1.
      local backward_penalty = 1.
      if forward_is_unsafe then
        forward_penalty = math.min(forward_penalty, safety_penalty)
      end
      if backward_is_unsafe then
         backward_penalty = math.min(backward_penalty, safety_penalty)
      end

      if is_undesireable then
         forward_penalty = math.min(forward_penalty, profile.service_penalties[service])
         backward_penalty = math.min(backward_penalty, profile.service_penalties[service])
      end

      if result.forward_speed > 0 then
        -- convert from km/h to m/s
        result.forward_rate = result.forward_speed / 3.6 * forward_penalty
      end
      if result.backward_speed > 0 then
        -- convert from km/h to m/s
        result.backward_rate = result.backward_speed / 3.6 * backward_penalty
      end
      if result.duration > 0 then
        result.weight = result.duration / forward_penalty
      end
  end
end
function process_way(profile, way, result)
  -- the initial filtering of ways based on presence of tags
  -- affects processing times significantly, because all ways
  -- have to be checked.
  -- to increase performance, prefetching and initial tag check
  -- is done 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'),
  }

  local 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,

    -- our main handler
    handle_bicycle_tags,

    -- compute speed taking into account way type, maxspeed tags, etc.
    WayHandlers.surface,

    -- handle turn lanes and road classification, used for guidance
    WayHandlers.classification,

    -- handle allowed start/end modes
    WayHandlers.startpoint,

    -- handle roundabouts
    WayHandlers.roundabouts,

    -- set name, ref and pronunciation
    WayHandlers.names,

    -- set weight properties of the way
    WayHandlers.weights
  }

  WayHandlers.run(profile, way, result, data, handlers)
end

function process_turn(profile, turn)
  -- compute turn penalty as angle^2, with a left/right bias
  local normalized_angle = turn.angle / 90.0
  if normalized_angle >= 0.0 then
    turn.duration = normalized_angle * normalized_angle * profile.turn_penalty / profile.turn_bias
  else
    turn.duration = normalized_angle * normalized_angle * profile.turn_penalty * profile.turn_bias
  end

  if turn.direction_modifier == direction_modifier.uturn then
    turn.duration = turn.duration + profile.properties.u_turn_penalty
  end

  if turn.has_traffic_light then
     turn.duration = turn.duration + profile.properties.traffic_light_penalty
  end
  if profile.properties.weight_name == 'cyclability' then
    turn.weight = turn.duration
  end
end

return {
  setup = setup,
  process_way = process_way,
  process_node = process_node,
  process_turn = process_turn
}