Merge branch 'DeloitteDigitalAPAC-master'

Author: rush42

Project.toml

@@ -1,7 +1,7 @@
 name = "LightOSM"
 uuid = "d1922b25-af4e-4ba3-84af-fe9bea896051"
 authors = ["Jack Chan <[email protected]>"]
-version = "0.1.19"
+version = "0.1.20"
 
 [deps]
 DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"

docs/src/testing_use.md

@@ -66,7 +66,7 @@ Creating the graph relies on some LightOSM internals to populate all other field
 U = LightOSM.DEFAULT_OSM_INDEX_TYPE
 T = LightOSM.DEFAULT_OSM_ID_TYPE
 W = LightOSM.DEFAULT_OSM_EDGE_WEIGHT_TYPE
-g = OSMGraph{U,T,W}(nodes=nodes, highways=ways)
+g = OSMGraph{U,T,W}(nodes=nodes, ways=ways)
 LightOSM.add_node_and_edge_mappings!(g)
 LightOSM.add_weights!(g, :distance) # or :time
 LightOSM.add_graph!(g, :static) # or any desired graph type
@@ -99,7 +99,7 @@ See [`Restriction`](@ref) for more information on `Restriction` objects.
 And then when instantiating the `OSMGraph`
 
 ```julia
-g = OSMGraph{U,T,W}(nodes=nodes, highways=ways, restrictions=restrictions)
+g = OSMGraph{U,T,W}(nodes=nodes, ways=ways, restrictions=restrictions)
 LightOSM.add_indexed_restrictions!(g)
 ```
 

src/graph.jl

@@ -173,15 +173,15 @@ end
 
 
 """
-Adds mappings between nodes, edges and highways to `OSMGraph`.
+Adds mappings between nodes, edges and ways to `OSMGraph`.
 """
 function add_node_and_edge_mappings!(g::OSMGraph{U,T,W}) where {U <: Integer,T <: Integer,W <: Real}
-    for (way_id, way) in g.highways
+    for (way_id, way) in g.ways
         @inbounds for (i, node_id) in enumerate(way.nodes)
-            if haskey(g.node_to_highway, node_id)
-                push!(g.node_to_highway[node_id], way_id)
+            if haskey(g.node_to_way, node_id)
+                push!(g.node_to_way[node_id], way_id)
             else
-                g.node_to_highway[node_id] = [way_id]
+                g.node_to_way[node_id] = [way_id]
             end
 
             if i < length(way.nodes)
@@ -193,16 +193,16 @@ function add_node_and_edge_mappings!(g::OSMGraph{U,T,W}) where {U <: Integer,T <
                     d = way.nodes[i]
                 end
 
-                g.edge_to_highway[[o, d]] = way_id
+                g.edge_to_way[[o, d]] = way_id
 
                 if !way.tags["oneway"]::Bool
-                    g.edge_to_highway[[d, o]] = way_id
+                    g.edge_to_way[[d, o]] = way_id
                 end
             end                
         end
     end
 
-    @assert(length(g.nodes) == length(g.node_to_highway), "Data quality issue: number of graph nodes ($(length(g.nodes::Dict{T,Node{T}}))) not equal to set of nodes extracted from highways ($(length(g.node_to_highway)))")
+    @assert(length(g.nodes) == length(g.node_to_way), "Data quality issue: number of graph nodes ($(length(g.nodes::Dict{T,Node{T}}))) not equal to set of nodes extracted from ways ($(length(g.node_to_way)))")
     g.node_to_index = OrderedDict{T,U}(n => i for (i, n) in enumerate(collect(keys(g.nodes))))
     g.index_to_node = OrderedDict{U,T}(i => n for (n, i) in g.node_to_index)
 end
@@ -215,7 +215,7 @@ function add_node_tags!(g::OSMGraph)
     @inline function _roundedmean(hwys, subkey, T)
         total = zero(T)
         for id in hwys
-            total += g.highways[id].tags[subkey]::T
+            total += g.ways[id].tags[subkey]::T
         end
         return round(T, total/length(hwys))
     end
@@ -224,10 +224,10 @@ function add_node_tags!(g::OSMGraph)
     L = DEFAULT_OSM_LANES_TYPE
 
     for (id, data) in g.nodes
-        highways = g.node_to_highway[id]
+        ways = g.node_to_way[id]
         tags_dict = g.nodes[id].tags::Dict{String, Any}
-        tags_dict["maxspeed"] = _roundedmean(highways, "maxspeed", M)
-        tags_dict["lanes"] = _roundedmean(highways, "lanes", L)
+        tags_dict["maxspeed"] = _roundedmean(ways, "maxspeed", M)
+        tags_dict["lanes"] = _roundedmean(ways, "lanes", L)
         push!(g.node_coordinates, [data.location.lat, data.location.lon])
     end
 end
@@ -236,15 +236,15 @@ end
 Finds the adjacent node id on a given way.
 """
 function adjacent_node(g::OSMGraph, node::T, way::T)::Union{T,Vector{<:T}} where T <: Integer
-    way_nodes = g.highways[way].nodes
+    way_nodes = g.ways[way].nodes
     if node == way_nodes[1]
         return way_nodes[2]
     elseif node == way_nodes[end]
         return way_nodes[length(way_nodes) - 1]
     else
         idx = findfirst(isequal(node), way_nodes)
-        is_oneway = g.highways[way].tags["oneway"]
-        is_reverseway = g.highways[way].tags["reverseway"]
+        is_oneway = g.ways[way].tags["oneway"]
+        is_reverseway = g.ways[way].tags["reverseway"]
         if is_oneway && !is_reverseway
             return way_nodes[idx + 1]
         elseif is_oneway && is_reverseway
@@ -274,7 +274,7 @@ function add_indexed_restrictions!(g::OSMGraph{U,T,W}) where {U <: Integer,T <:
             elseif r.is_exclusive
                 # only_right_turn, only_left_turn, only_straight_on
                 # Multiple to_ways, e.g. if only_right_turn, then left turn and straight on are restricted
-                all_ways = g.node_to_highway[r.via_node]
+                all_ways = g.node_to_way[r.via_node]
                 permitted_to_way = r.to_way
                 restricted_to_ways = [w for w in all_ways if w != r.from_way && w != permitted_to_way]
             else
@@ -294,14 +294,14 @@ function add_indexed_restrictions!(g::OSMGraph{U,T,W}) where {U <: Integer,T <:
             end
 
         elseif r.type == "via_way"
-            via_way_nodes_list = [g.highways[w].nodes for w in r.via_way::Vector{T}]
+            via_way_nodes_list = [g.ways[w].nodes for w in r.via_way::Vector{T}]
             via_way_nodes = join_arrays_on_common_trailing_elements(via_way_nodes_list...)::Vector{T}
 
-            from_way_nodes = g.highways[r.from_way].nodes
+            from_way_nodes = g.ways[r.from_way].nodes
             from_via_intersection_node = first_common_trailing_element(from_way_nodes, via_way_nodes)
             from_node = adjacent_node(g, from_via_intersection_node, r.from_way)::T
 
-            to_way_nodes = g.highways[r.to_way].nodes
+            to_way_nodes = g.ways[r.to_way].nodes
             to_via_intersection_node = first_common_trailing_element(to_way_nodes, via_way_nodes)
             to_node = adjacent_node(g, to_via_intersection_node, r.to_way)::T
 
@@ -321,14 +321,14 @@ end
 Adds edge weights to `OSMGraph`.
 """
 function add_weights!(g::OSMGraph, weight_type::Symbol=:distance)
-    n_edges = length(g.edge_to_highway)
+    n_edges = length(g.edge_to_way)
     o_indices = Vector{Int}(undef, n_edges) # edge origin node indices
     d_indices = Vector{Int}(undef, n_edges) # edge destination node indices
     weights = Vector{Float64}(undef, n_edges)
 
     W = DEFAULT_OSM_EDGE_WEIGHT_TYPE
 
-    @inbounds for (i, edge) in enumerate(keys(g.edge_to_highway))
+    @inbounds for (i, edge) in enumerate(keys(g.edge_to_way))
         o_loc = g.nodes[edge[1]].location
         d_loc = g.nodes[edge[2]].location
 
@@ -337,12 +337,12 @@ function add_weights!(g::OSMGraph, weight_type::Symbol=:distance)
 
         dist = distance(o_loc, d_loc, :haversine)
         if weight_type == :time || weight_type == :lane_efficiency
-            highway = g.edge_to_highway[edge]
-            maxspeed = g.highways[highway].tags["maxspeed"]::DEFAULT_OSM_MAXSPEED_TYPE
+            highway = g.edge_to_way[edge]
+            maxspeed = g.ways[highway].tags["maxspeed"]::DEFAULT_OSM_MAXSPEED_TYPE
             if weight_type == :time
                 weight = dist / maxspeed
             else
-                lanes = g.highways[highway].tags["lanes"]::DEFAULT_OSM_LANES_TYPE
+                lanes = g.ways[highway].tags["lanes"]::DEFAULT_OSM_LANES_TYPE
                 lane_efficiency = get(LANE_EFFICIENCY, lanes, 1.0)
                 weight = dist / (maxspeed * lane_efficiency)
             end
@@ -387,21 +387,21 @@ function trim_to_largest_connected_component!(g::OSMGraph{U, T, W}, graph, weigh
     sort!(cc, by=x -> length(x), rev=true)
     indices_to_delete = flatten(cc[2:end])
     nodes_to_delete = [g.index_to_node[i] for i in indices_to_delete]
-    highways_to_delete = Set(flatten([g.node_to_highway[n] for n in nodes_to_delete]))
+    ways_to_delete = Set(flatten([g.node_to_way[n] for n in nodes_to_delete]))
 
     delete_from_dict!(g.nodes, nodes_to_delete, :on_key)
     delete_from_dict!(g.node_to_index, nodes_to_delete, :on_key)
-    delete_from_dict!(g.node_to_highway, nodes_to_delete, :on_key)
+    delete_from_dict!(g.node_to_way, nodes_to_delete, :on_key)
     delete_from_dict!(g.index_to_node, indices_to_delete, :on_key)
-    delete_from_dict!(g.highways, highways_to_delete, :on_key)
-    delete_from_dict!(g.edge_to_highway, highways_to_delete, :on_value)
+    delete_from_dict!(g.ways, ways_to_delete, :on_key)
+    delete_from_dict!(g.edge_to_way, ways_to_delete, :on_value)
 
     for (id, r) in g.restrictions
         if r.via_node !== nothing
             !isempty(intersect([r.via_node::T], nodes_to_delete)) && delete!(g.restrictions, id)
         elseif r.via_way !== nothing
             ways = Set([r.from_way, r.to_way, r.via_way::Vector{T}...])
-            !isempty(intersect(ways, highways_to_delete)) && delete!(g.restrictions, id)
+            !isempty(intersect(ways, ways_to_delete)) && delete!(g.restrictions, id)
         end
     end
 

src/nearest_node.jl

@@ -21,7 +21,7 @@ function nearest_node(g::OSMGraph{U, T, W},
     cartesian_locations = LightOSM.to_cartesian(points)
     idxs, dists = knn(g.kdtree, cartesian_locations, n_neighbours, true)
     neighbours = [[g.index_to_node[j] for j in i] for i in idxs]
-    dists = [d for d in dists]
+    dists = collect(dists)
     return  neighbours, dists
 end
 

src/parse.jl

@@ -122,7 +122,7 @@ is_restriction(tags::AbstractDict)::Bool = get(tags, "type", "") == "restriction
 """
 Determine if a restriction is valid and has usable data.
 """
-function is_valid_restriction(members::AbstractArray, highways::AbstractDict{T,Way{T}})::Bool where T <: Integer
+function is_valid_restriction(members::AbstractArray, ways::AbstractDict{T,Way{T}})::Bool where T <: Integer
     role_counts = DefaultDict(0)
     role_type_counts = DefaultDict(0)
     ways_set = Set{Int}()
@@ -135,7 +135,7 @@ function is_valid_restriction(members::AbstractArray, highways::AbstractDict{T,W
         role = member["role"]
 
         if type == "way"
-            if !haskey(highways, id) || id in ways_set
+            if !haskey(ways, id) || id in ways_set
                 # Cannot process missing and duplicate from/via/to ways
                 return false
             else
@@ -164,9 +164,9 @@ function is_valid_restriction(members::AbstractArray, highways::AbstractDict{T,W
     end
 
     to_way = ways_mapping["to"][1]
-    trailing_to_way_nodes = trailing_elements(highways[to_way].nodes)
+    trailing_to_way_nodes = trailing_elements(ways[to_way].nodes)
     from_way = ways_mapping["from"][1]
-    trailing_from_way_nodes = trailing_elements(highways[from_way].nodes)
+    trailing_from_way_nodes = trailing_elements(ways[from_way].nodes)
 
     if via_node isa Integer && (!(via_node in trailing_to_way_nodes) || !(via_node in trailing_from_way_nodes))
         # Via node must be a trailing node on to_way and from_way
@@ -177,7 +177,7 @@ function is_valid_restriction(members::AbstractArray, highways::AbstractDict{T,W
         try
             # Via way trailing nodes must intersect with all to_ways and from_ways
             via_ways = ways_mapping["via"]
-            via_way_nodes_list = [highways[w].nodes for w in via_ways]
+            via_way_nodes_list = [ways[w].nodes for w in via_ways]
             via_way_nodes = join_arrays_on_common_trailing_elements(via_way_nodes_list...)
             trailing_via_way_nodes = trailing_elements(via_way_nodes)
 
@@ -202,7 +202,7 @@ function parse_osm_network_dict(osm_network_dict::AbstractDict, network_type::Sy
     T = DEFAULT_OSM_ID_TYPE
     W = DEFAULT_OSM_EDGE_WEIGHT_TYPE
 
-    highways = Dict{T,Way{T}}()
+    ways = Dict{T,Way{T}}()
     highway_nodes = Set{Int}([])
     for way in osm_network_dict["way"]
         if haskey(way, "tags") && haskey(way, "nodes")
@@ -215,7 +215,7 @@ function parse_osm_network_dict(osm_network_dict::AbstractDict, network_type::Sy
                 nds = way["nodes"]
                 union!(highway_nodes, nds)
                 id = way["id"]
-                highways[id] = Way(id, nds, tags)
+                ways[id] = Way(id, nds, tags)
             elseif is_railway(tags) && matches_network_type(tags, network_type)
                 tags["rail_type"] = haskey(tags,"railway") ? tags["railway"] : "unknown"
                 tags["electrified"] = haskey(tags,"electrified") ? tags["electrified"] : "unknown"
@@ -229,7 +229,7 @@ function parse_osm_network_dict(osm_network_dict::AbstractDict, network_type::Sy
                 nds = way["nodes"]
                 union!(highway_nodes, nds)
                 id = way["id"]
-                highways[id] = Way(id, nds, tags)
+                ways[id] = Way(id, nds, tags)
             end
         end
     end
@@ -253,7 +253,7 @@ function parse_osm_network_dict(osm_network_dict::AbstractDict, network_type::Sy
                 tags = relation["tags"]
                 members = relation["members"]
 
-                if is_restriction(tags) && is_valid_restriction(members, highways)
+                if is_restriction(tags) && is_valid_restriction(members, ways)
                     restriction_kwargs = DefaultDict(Vector)
                     for member in members
                         key = "$(member["role"])_$(member["type"])"
@@ -277,7 +277,7 @@ function parse_osm_network_dict(osm_network_dict::AbstractDict, network_type::Sy
             end
         end
     end
-    return OSMGraph{U,T,W}(nodes=nodes, highways=highways, restrictions=restrictions)
+    return OSMGraph{U,T,W}(nodes=nodes, ways=ways, restrictions=restrictions)
 end
 
 """

src/simplification.jl

@@ -45,10 +45,22 @@ function path_to_endpoint(g::AbstractGraph, (ep, ep_succ)::Tuple{T,T}) where {T<
     return path
 end
 
+"""
+Return the total weight of a path given as a Vector of Ids.
+"""
 function total_weight(g::OSMGraph, path::Vector{<:Integer})
     sum((g.weights[path[[i, i+1]]...] for i in 1:length(path)-1))
 end
 
+function ways_in_path(g::OSMGraph, path::Vector{<:Integer})
+    ways = Set{Int}()
+    for i in 1:(length(path)-1)
+        edge = [g.index_to_node[path[i]], g.index_to_node[path[i+1]]]
+        push!(ways, g.edge_to_way[edge])
+    end
+    return collect(ways)
+end
+
 """
 Build a new graph which simplifies the topology of osmg.graph.
 The resulting graph only contains intersections and dead ends from the original graph.
@@ -79,7 +91,6 @@ function simplify_graph(osmg::OSMGraph{U, T, W}) where {U, T, W}
         u = index_mapping[first(path)]
         v = index_mapping[last(path)]
         path_weight = total_weight(osmg, path)
-
         if add_edge!(graph, (u, v))
             key = 0
             weights[u, v] = path_weight
@@ -92,12 +103,17 @@ function simplify_graph(osmg::OSMGraph{U, T, W}) where {U, T, W}
         edges[u,v,key] = path
     end
 
+    edge_to_way = Dict{NTuple{3,U}, Vector{T}}()
+    for (edge, path) in edges
+        edge_to_way[edge] = ways_in_path(osmg, path)
+    end
+
     return SimplifiedOSMGraph(
                 osmg,
                 node_coordinates,
                 node_to_index,
                 index_to_node,
-                Dict{Vector{T}, Vector{T}}(),
+                edge_to_way,
                 graph,
                 edges,
                 weights,

src/types.jl

@@ -86,11 +86,11 @@ Container for storing OpenStreetMap node, way, relation and graph related obejct
 `U <: Integer,T <: Integer,W <: Real`
 - `nodes::Dict{T,Node{T}}`: Mapping of node ids to node objects.
 - `node_coordinates::Vector{Vector{W}}`: Vector of node coordinates [[lat, lon]...], indexed by graph vertices.
-- `highways::Dict{T,Way{T}}`: Mapping of way ids to way objects.
+- `ways::Dict{T,Way{T}}`: Mapping of way ids to way objects. Previously called `highways`.
 - `node_to_index::OrderedDict{T,U}`: Mapping of node ids to graph vertices.
 - `index_to_node::OrderedDict{U,T}`: Mapping of graph vertices to node ids.
-- `node_to_highway::Dict{T,Vector{T}}`: Mapping of node ids to vector of way ids.
-- `edge_to_highway::Dict{Vector{T},T}`: Mapping of edges (adjacent node pairs) to way ids.
+- `node_to_way::Dict{T,Vector{T}}`: Mapping of node ids to vector of way ids. Previously called `node_to_highway`.
+- `edge_to_way::Dict{Vector{T},T}`: Mapping of edges (adjacent node pairs) to way ids. Previously called `edge_to_highway`.
 - `restrictions::Dict{T,Restriction{T}}`: Mapping of relation ids to restriction objects.
 - `indexed_restrictions::Union{DefaultDict{U,Vector{MutableLinkedList{U}}},Nothing}`: Mapping of via node ids to ordered sequences of restricted node ids.
 - `graph::Union{AbstractGraph,Nothing}`: Either DiGraph, StaticDiGraph, SimpleWeightedDiGraph or MetaDiGraph.
@@ -104,11 +104,11 @@ abstract type AbstractOSMGraph end
 @with_kw mutable struct OSMGraph{U <: Integer,T <: Integer,W <: Real} <: AbstractOSMGraph
     nodes::Dict{T,Node{T}} = Dict{T,Node{T}}()
     node_coordinates::Vector{Vector{W}} = Vector{Vector{W}}() # needed for astar heuristic
-    highways::Dict{T,Way{T}} = Dict{T,Way{T}}()
+    ways::Dict{T,Way{T}} = Dict{T,Way{T}}()
     node_to_index::OrderedDict{T,U} = OrderedDict{T,U}()
     index_to_node::OrderedDict{U,T} = OrderedDict{U,T}()
-    node_to_highway::Dict{T,Vector{T}} = Dict{T,Vector{T}}()
-    edge_to_highway::Dict{Vector{T},T} = Dict{Vector{T},T}()
+    node_to_way::Dict{T,Vector{T}} = Dict{T,Vector{T}}()
+    edge_to_way::Dict{Vector{T},T} = Dict{Vector{T},T}()
     restrictions::Dict{T,Restriction{T}} = Dict{T,Restriction{T}}()
     indexed_restrictions::Union{DefaultDict{U,Vector{MutableLinkedList{U}}},Nothing} = nothing
     graph::Union{AbstractGraph,Nothing} = nothing
@@ -123,13 +123,26 @@ struct SimplifiedOSMGraph{U <: Integer,T <: Integer,W <: Real} <: AbstractOSMGra
     node_coordinates::Vector{Vector{W}} # needed for astar heuristic
     node_to_index::OrderedDict{T,U}
     index_to_node::OrderedDict{U,T}
-    edge_to_highway::Dict{Vector{T},Vector{T}}
+    edge_to_way::Dict{NTuple{3,U},Vector{T}}
     graph::Union{AbstractGraph,Nothing}
     edges::Dict{NTuple{3, U}, Vector{U}}
     weights::Union{SparseMatrixCSC{W,U},Nothing}
     dijkstra_states::Union{Vector{Vector{U}},Nothing}
 end
 
+function Base.getproperty(g::OSMGraph, field::Symbol)
+    # Ensure renaming of "highways" to "ways" is backwards compatible
+    if field === :highways
+        return getfield(g, :ways)
+    elseif field === :node_to_highway
+        return getfield(g, :node_to_way)
+    elseif field === :edge_to_highway
+        return getfield(g, :edge_to_way)
+    else
+        return getfield(g, field)
+    end
+end
+
 """
 OpenStreetMap building polygon.