def create_map(fn=osm_fn, include_footways=False, include_parking=False):
map_con = InMemMap("map", use_latlon=True)
cnt = 0
ways_filter = ['bridleway', 'bus_guideway', 'track']
if not include_footways:
ways_filter += ['footway', 'cycleway', 'path']
parking_filter = ['driveway']
if not include_parking:
parking_filter += ['parking_aisle']
for entity in osmread.parse_file(str(fn)):
if isinstance(entity, osmread.Way):
tags = entity.tags
if 'highway' in tags \
and not (tags['highway'] in ways_filter) \
and not ('access' in tags and tags['access'] == 'private') \
and not ('landuse' in tags and tags['landuse'] == 'square') \
and not ('amenity' in tags and tags['amenity'] == 'parking') \
and not ('service' in tags and tags['service'] in parking_filter) \
and not ('area' in tags and tags['area'] == 'yes'):
for node_a, node_b in zip(entity.nodes, entity.nodes[1:]):
map_con.add_edge(node_a, node_b)
# Some roads are one-way. We'll add both directions.
map_con.add_edge(node_b, node_a)
if isinstance(entity, osmread.Node):
map_con.add_node(entity.id, (entity.lat, entity.lon))
map_con.purge()
return map_con
def create_map_osmread() -> None:
xml_file = Path("./tests") / "osm.xml"
map_con = InMemMap("myosm",
use_latlon=True,
use_rtree=True,
index_edges=True)
for entity in osmread.parse_file(str(xml_file)):
if isinstance(entity, osmread.Way) and 'highway' in entity.tags:
for node_a, node_b in zip(entity.nodes, entity.nodes[1:]):
map_con.add_edge(node_a, node_b)
# Some roads are one-way. We'll add both directions.
map_con.add_edge(node_b, node_a)
if isinstance(entity, osmread.Node):
map_con.add_node(entity.id, (entity.lat, entity.lon))
map_con.purge()
def test_path3_few_obs_e():
path = [(1, 0), (7.5, 0.65), (10.1, 1.9)]
path_sol = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
mapdb = InMemMap("map", graph={
"A": ((1, 0.00), ["B"]),
"B": ((3, 0.00), ["A", "C"]),
"C": ((4, 0.70), ["B", "D"]),
"D": ((5, 1.00), ["C", "E"]),
"E": ((6, 1.00), ["D", "F"]),
"F": ((7, 0.70), ["E", "G"]),
"G": ((8, 0.00), ["F", "H"]),
"H": ((10, 0.0), ["G", "I"]),
"I": ((10, 2.0), ["H"])
}, use_latlon=False)
matcher = SimpleMatcher(mapdb, max_dist_init=0.2, obs_noise=1, obs_noise_ne=10,
non_emitting_states=True, only_edges=True)
matcher.match(path)
path_pred = matcher.path_pred_onlynodes
if directory:
matcher.print_lattice_stats()
matcher.print_lattice()
from leuvenmapmatching import visualization as mmviz
mmviz.plot_map(mapdb, matcher=matcher, show_labels=True, show_matching=True, linewidth=10,
filename=str(directory / "test_test_path_e_3_fo.png"))
assert path_pred == path_sol, f"Nodes not equal:\n{path_pred}\n{path_sol}"
def test_path3_dist():
path = [(0, 1), (0.65, 7.5), (1.9, 10.1)]
path_sol = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
mapdb = InMemMap("map", graph={
"A": ((0.00, 1), ["B"]),
"B": ((0.00, 3), ["A", "C"]),
"C": ((0.70, 3), ["B", "D"]),
"D": ((1.00, 5), ["C", "E"]),
"E": ((1.00, 6), ["D", "F"]),
"F": ((0.70, 7), ["E", "G"]),
"G": ((0.00, 8), ["F", "H"]),
"H": ((0.0, 10), ["G", "I"]),
"I": ((2.0, 10), ["H"])
}, use_latlon=False)
matcher = DistanceMatcher(mapdb, max_dist_init=0.2,
obs_noise=0.5, obs_noise_ne=2, dist_noise=0.5,
non_emitting_states=True)
states, lastidx = matcher.match(path)
path_pred = matcher.path_pred_onlynodes
if directory:
from leuvenmapmatching import visualization as mmviz
mmviz.plot_map(mapdb, matcher=matcher, show_labels=True, show_matching=True, linewidth=2,
filename=str(directory / "test_path_3_dist.png"))
assert path_pred == path_sol, f"Nodes not equal:\n{path_pred}\n{path_sol}"
for obs_idx, m in enumerate(matcher.lattice_best): # type: Tuple[int, DistanceMatching]
state = m.shortkey # tuple indicating edge
ne_str = "e" if m.is_emitting() else "ne" # state is emitting or not
p1_str = "{:>5.2f}-{:<5.2f}".format(*m.edge_m.pi) # best matching location on graph
p2_str = "{:>5.2f}-{:<5.2f}".format(*m.edge_o.pi) # best matching location on track
print(f"{obs_idx:<2} | {state} | {ne_str:<2} | {p1_str} | {p2_str}")
def test_path_duplicate():
from datetime import datetime
# A path with two identical points
path = [(0.8, 0.7), (0.9, 0.7), (1.1, 1.0), (1.2, 1.5), (1.2, 1.5), (1.2, 1.6), (1.1, 2.0),
(1.1, 2.3), (1.3, 2.9), (1.2, 3.1), (1.5, 3.2), (1.8, 3.5), (2.0, 3.7),
(2.1, 3.3), (2.4, 3.2), (2.6, 3.1), (2.9, 3.1), (3.0, 3.2), (3.1, 3.8),
(3.0, 4.0), (3.1, 4.3), (3.1, 4.6), (3.0, 4.9)]
mapdb = InMemMap("map", graph={
"A": ((1, 1), ["B", "C"]),
"B": ((1, 3), ["A", "C", "D"]),
"C": ((2, 2), ["A", "B", "D", "E"]),
"D": ((2, 4), ["B", "C", "D", "E"]),
"E": ((3, 3), ["C", "D", "F"]),
"F": ((3, 5), ["D", "E"])
}, use_latlon=False)
matcher = SimpleMatcher(mapdb, max_dist=None, min_prob_norm=None,
non_emitting_states = True, only_edges=False)
#Matching with and without timestamps signed to the points
path_pred = matcher.match(path, unique=False)
path = [(p1, p2, datetime.fromtimestamp(i)) for i, (p1, p2) in enumerate(path)]
path_pred_time = matcher.match(path, unique=False)
if directory:
from leuvenmapmatching import visualization as mmviz
matcher.print_lattice_stats()
matcher.print_lattice()
mmviz.plot_map(mapdb, matcher=matcher, show_labels=True, show_matching=True,
filename=str(directory / "test_nonemitting_test_path_duplicate.png"))
# The path should be identical regardless of the timestamps
assert path_pred == path_pred_time, f"Nodes not equal:\n{path_pred}\n{path_pred_time}"
def test_path2():
path = [(0.8, 0.7), (0.9, 0.7), (1.1, 1.0), (1.2, 1.5), (1.2, 1.6), (1.1, 2.0),
(1.1, 2.3), (1.3, 2.9), (1.2, 3.1), (1.5, 3.2), (1.8, 3.5), (2.0, 3.7),
(2.1, 3.3), (2.4, 3.2), (2.6, 3.1), (2.9, 3.1), (3.0, 3.2), (3.1, 3.8),
(3.0, 4.0), (3.1, 4.3), (3.1, 4.6), (3.0, 4.9)]
# path_sol = ['A', ('A', 'B'), 'B', ('B', 'D'), 'D', ('D', 'E'), 'E', ('E', 'F')]
path_sol_nodes = ['A', 'B', 'D', 'E', 'F']
mapdb = InMemMap("map", graph={
"A": ((1, 1), ["B", "C", "X"]),
"B": ((1, 3), ["A", "C", "D", "K"]),
"C": ((2, 2), ["A", "B", "D", "E", "X", "Y"]),
"D": ((2, 4), ["B", "C", "F", "E", "K", "L"]),
"E": ((3, 3), ["C", "D", "F", "Y"]),
"F": ((3, 5), ["D", "E", "L"]),
"X": ((2, 0), ["A", "C", "Y"]),
"Y": ((3, 1), ["X", "C", "E"]),
"K": ((1, 5), ["B", "D", "L"]),
"L": ((2, 6), ["K", "D", "F"])
}, use_latlon=False)
matcher = SimpleMatcher(mapdb, max_dist=None, min_prob_norm=0.001,
non_emitting_states=False, only_edges=False)
path_pred, _ = matcher.match(path, unique=True)
if directory:
matcher.print_lattice_stats()
matcher.print_lattice()
from leuvenmapmatching import visualization as mmviz
mmviz.plot_map(mapdb, matcher=matcher, show_labels=True, show_matching=True,
filename=str(directory / "test_path2.png"))
# assert path_pred == path_sol, "Nodes not equal:\n{}\n{}".format(path_pred, path_sol)
nodes_pred = matcher.path_pred_onlynodes
assert nodes_pred == path_sol_nodes, f"Nodes not equal:\n{nodes_pred}\n{path_sol_nodes}"
def test_path_outlier():
path = [(0.8, 0.7), (0.9, 0.7), (1.1, 1.0), (1.2, 1.5), (1.2, 1.6), (1.1, 2.0),
(1.1, 2.3), (1.3, 2.9), (1.2, 3.1), (1.5, 3.2), (1.8, 3.5), (2.0, 3.7),
(2.1, 3.3), (2.4, 3.2), (2.6, 3.1), (2.9, 3.1), (3.0, 3.2), (3.1, 3.8),
(3.0, 4.0), (3.1, 4.3), (3.1, 4.6), (3.0, 4.9)]
path_sol = ['A', 'B', 'D', 'C', 'D', 'E', 'F']
path.insert(13, (2.3, 1.8))
mapdb = InMemMap("map", graph={
"A": ((1, 1), ["B", "C", "X"]),
"B": ((1, 3), ["A", "C", "D", "K"]),
"C": ((2, 2), ["A", "B", "D", "E", "X", "Y"]),
"D": ((2, 4), ["B", "C", "F", "E", "K", "L"]),
"E": ((3, 3), ["C", "D", "F", "Y"]),
"F": ((3, 5), ["D", "E", "L"]),
"X": ((2, 0), ["A", "C", "Y"]),
"Y": ((3, 1), ["X", "C", "E"]),
"K": ((1, 5), ["B", "D", "L"]),
"L": ((2, 6), ["K", "D", "F"])
}, use_latlon=False)
matcher = SimpleMatcher(mapdb, max_dist=None, min_prob_norm=0.0001,
max_dist_init=1, obs_noise=0.5, obs_noise_ne=10,
non_emitting_states=True)
matcher.match(path, unique=True)
path_pred = matcher.path_pred_onlynodes
if directory:
matcher.print_lattice_stats()
matcher.print_lattice()
from leuvenmapmatching import visualization as mmviz
with (directory / 'lattice.gv').open('w') as ofile:
matcher.lattice_dot(file=ofile)
mmviz.plot_map(mapdb, matcher=matcher, show_labels=True, show_matching=True,
filename=str(directory / "test_path_outlier.png"))
print("Path through lattice:\n" + "\n".join(m.label for m in matcher.lattice_best))
assert path_pred == path_sol, "Nodes not equal:\n{}\n{}".format(path_pred, path_sol)
def test_path_outlier_dist():
path = [(0.8, 0.7), (0.9, 0.7), (1.1, 1.0), (1.2, 1.5), (1.2, 1.6), (1.1, 2.0),
(1.1, 2.3), (1.3, 2.9), (1.2, 3.1), (1.5, 3.2), (1.8, 3.5), (2.0, 3.7),
(2.1, 3.3), (2.4, 3.2), (2.6, 3.1), (2.9, 3.1), (3.0, 3.2), (3.1, 3.8),
(3.0, 4.0), (3.1, 4.3), (3.1, 4.6), (3.0, 4.9)]
path_sol = ['A', 'B', 'D', 'C', 'E', 'F']
path.insert(13, (2.3, 1.8))
mapdb = InMemMap("map", graph={
"A": ((1, 1), ["B", "C", "X"]),
"B": ((1, 3), ["A", "C", "D", "K"]),
"C": ((2, 2), ["A", "B", "D", "E", "X", "Y"]),
"D": ((2, 4), ["B", "C", "F", "E", "K", "L"]),
"E": ((3, 3), ["C", "D", "F", "Y"]),
"F": ((3, 5), ["D", "E", "L"]),
"X": ((2, 0), ["A", "C", "Y"]),
"Y": ((3, 1), ["X", "C", "E"]),
"K": ((1, 5), ["B", "D", "L"]),
"L": ((2, 6), ["K", "D", "F"])
}, use_latlon=False)
matcher = DistanceMatcher(mapdb, max_dist=None, min_prob_norm=0.0001,
max_dist_init=1, obs_noise=0.5, obs_noise_ne=10,
non_emitting_states=True)
matcher.match(path)
path_pred = matcher.path_pred_onlynodes
if directory:
from leuvenmapmatching import visualization as mmviz
mmviz.plot_map(mapdb, matcher=matcher,
show_labels=True, show_matching=True, show_graph=True,
filename=str(directory / "test_path_outlier_dist.png"))
# TODO: Smoothing the observation distances could eliminate the outlier
assert path_pred == path_sol, "Nodes not equal:\n{}\n{}".format(path_pred, path_sol)
def test_path_outlier2():
path = [(0.8, 0.7), (0.9, 0.7), (1.1, 1.0), (1.2, 1.5), (1.2, 1.6), (1.1, 2.0),
(1.1, 2.3), (1.3, 2.9), (1.2, 3.1), (1.5, 3.2), (1.8, 3.5), (2.0, 3.7),
(2.1, 3.3), (2.4, 3.2), (2.6, 3.1), (2.9, 3.1), (3.0, 3.2), (3.1, 3.8),
(3.0, 4.0), (3.1, 4.3), (3.1, 4.6), (3.0, 4.9)]
path.insert(13, (2.3, -3.0))
mapdb = InMemMap("map", graph={
"A": ((1, 1), ["B", "C", "X"]),
"B": ((1, 3), ["A", "C", "D", "K"]),
"C": ((2, 2), ["A", "B", "D", "E", "X", "Y"]),
"D": ((2, 4), ["B", "C", "F", "E", "K", "L"]),
"E": ((3, 3), ["C", "D", "F", "Y"]),
"F": ((3, 5), ["D", "E", "L"]),
"X": ((2, 0), ["A", "C", "Y"]),
"Y": ((3, 1), ["X", "C", "E"]),
"K": ((1, 5), ["B", "D", "L"]),
"L": ((2, 6), ["K", "D", "F"])
}, use_latlon=False)
matcher = DistanceMatcher(mapdb, max_dist=None, min_prob_norm=0.1,
max_dist_init=1, obs_noise=0.25, obs_noise_ne=1,
non_emitting_states=True)
_, last_idx = matcher.match(path, unique=True)
if directory:
# matcher.print_lattice_stats()
# matcher.print_lattice()
from leuvenmapmatching import visualization as mmviz
# with (directory / 'lattice.gv').open('w') as ofile:
# matcher.lattice_dot(file=ofile)
mmviz.plot_map(mapdb, matcher=matcher, show_labels=True, show_matching=True,
filename=str(directory / "test_path_outlier2.png"))
assert last_idx == 12
def test_path3_dist():
path = [(3.0, 3.2), (3.1, 3.8), (3.0, 4.0), (3.1, 4.3), (3.1, 4.6),
(3.0, 4.9)]
path_sol = ['E', 'F']
mapdb = InMemMap("map",
graph={
"E": ((3, 3), ["F"]),
"F": ((3, 5), ["E"]),
},
use_latlon=False)
matcher = DistanceMatcher(mapdb,
max_dist=None,
min_prob_norm=0.0001,
max_dist_init=1,
obs_noise=0.25,
obs_noise_ne=10,
non_emitting_states=True)
matcher.match(path, unique=True)
path_pred = matcher.path_pred_onlynodes
if directory:
from leuvenmapmatching import visualization as mmviz
mmviz.plot_map(mapdb,
matcher=matcher,
show_labels=True,
show_matching=True,
filename=str(directory / "test_path3_dist.png"))
print("Path through lattice:\n" +
"\n".join(m.label for m in matcher.lattice_best))
assert path_pred == path_sol, "Nodes not equal:\n{}\n{}".format(
path_pred, path_sol)
def test_path1_dist():
path = [(0.8, 0.7), (0.9, 0.7), (1.1, 1.0), (1.2, 1.5), (1.2, 1.6),
(1.1, 2.0), (1.1, 2.3), (1.3, 2.9), (1.2, 3.1), (1.5, 3.2),
(1.8, 3.5), (2.0, 3.7), (2.1, 3.3), (2.4, 3.2), (2.6, 3.1),
(2.9, 3.1), (3.0, 3.2), (3.1, 3.8), (3.0, 4.0), (3.1, 4.3),
(3.1, 4.6), (3.0, 4.9)]
# path_sol = ['A', ('A', 'B'), 'B', ('B', 'D'), 'D', ('D', 'E'), 'E', ('E', 'F')]
path_sol_nodes = ['A', 'B', 'D', 'E', 'F']
mapdb = InMemMap("map",
graph={
"A": ((1, 1), ["B", "C"]),
"B": ((1, 3), ["A", "C", "D"]),
"C": ((2, 2), ["A", "B", "D", "E"]),
"D": ((2, 4), ["B", "C", "D", "E"]),
"E": ((3, 3), ["C", "D", "F"]),
"F": ((3, 5), ["D", "E"])
},
use_latlon=False)
matcher = DistanceMatcher(mapdb,
max_dist=None,
min_prob_norm=None,
obs_noise=0.5,
non_emitting_states=False)
matcher.match(path)
if directory:
from leuvenmapmatching import visualization as mmviz
mmviz.plot_map(mapdb,
matcher=matcher,
show_labels=True,
show_matching=True,
filename=str(directory / "test_path1_dist.png"))
nodes_pred = matcher.path_pred_onlynodes
assert nodes_pred == path_sol_nodes, f"Nodes not equal:\n{nodes_pred}\n{path_sol_nodes}"
def example1():
map_con = InMemMap("mymap",
graph={
"A": ((1, 1), ["B", "C", "X"]),
"B": ((1, 3), ["A", "C", "D", "K"]),
"C": ((2, 2), ["A", "B", "D", "E", "X", "Y"]),
"D": ((2, 4), ["B", "C", "F", "E", "K", "L"]),
"E": ((3, 3), ["C", "D", "F", "Y"]),
"F": ((3, 5), ["D", "E", "L"]),
"X": ((2, 0), ["A", "C", "Y"]),
"Y": ((3, 1), ["X", "C", "E"]),
"K": ((1, 5), ["B", "D", "L"]),
"L": ((2, 6), ["K", "D", "F"])
},
use_latlon=False)
path = [(0.8, 0.7), (0.9, 0.7), (1.1, 1.0), (1.2, 1.5), (1.2, 1.6),
(1.1, 2.0), (1.1, 2.3), (1.3, 2.9), (1.2, 3.1), (1.5, 3.2),
(1.8, 3.5), (2.0, 3.7), (2.3, 3.5), (2.4, 3.2), (2.6, 3.1),
(2.9, 3.1), (3.0, 3.2), (3.1, 3.8), (3.0, 4.0), (3.1, 4.3),
(3.1, 4.6), (3.0, 4.9)]
matcher = DistanceMatcher(map_con,
max_dist=2,
obs_noise=1,
min_prob_norm=0.5)
states, _ = matcher.match(path)
nodes = matcher.path_pred_onlynodes
print("States\n------")
print(states)
print("Nodes\n------")
print(nodes)
print("")
matcher.print_lattice_stats()
def make_map(self, index_edges=True, rtree=True):
map_con = InMemMap(
"athensmap",
use_latlon=self.match_latlon,
index_edges=index_edges,
use_rtree=rtree) # Deprecated crs style in algorithm
if self.match_latlon:
for nid, rown in self.network_nodes.iterrows():
map_con.add_node(int(rown.n1), (rown.lat1, rown.lon1))
for eid, rowe in self.network_edges.iterrows():
map_con.add_edge(rowe.n1, rowe.n2)
else:
for nid, rown in self.network_nodes.iterrows():
map_con.add_node(int(rown.n1), (rown.y1, rown.x1))
for eid, rowe in self.network_edges.iterrows():
map_con.add_edge(rowe.n1, rowe.n2)
return map_con
def build_map_matching_graph(cls, road_network):
"""Return leuvenmapmatching.BaseMap used for map matching.
"""
# Create the Leuven.MapMatching graph
G = road_network.network
map_con = InMemMap('road_network',
use_latlon=False,
use_rtree=True,
index_edges=True,
crs_lonlat=None,
crs_xy=None,
graph=None)
for key in G.nodes:
node = G.nodes[key]
try:
map_con.add_node(key, (node['easting'], node['northing']))
except KeyError:
raise Exception('Must call '
'\'populate_meters_from_lon_lat\' first '
'to define the Cartesian coordinates '
'associated with the latitude and '
'longitude coordinates.')
for edge in G.edges:
map_con.add_edge(*edge)
return map_con
def get_InMemMap(graph):
'''
This function takes the OSMNX road network graph and returns a leuvenmapmatching InMem map
Parameters:
___________
graph: OSMNX road network
Returns:
__________
leuvenmapmatching InMem map
'''
# Leuven Map Matching is using a different internal graph structure for the street data.
# Therefore, the OSMnx graph needs to be transformed to the InMemMap
streetmap = InMemMap("enviroCar",
use_latlon=True,
use_rtree=True,
index_edges=True)
# add nodes
nodes = list(graph.nodes)
for node in nodes:
lng = graph.nodes[node]['x']
lat = graph.nodes[node]['y']
streetmap.add_node(node, (lat, lng))
# add edges
edges = list(graph.edges)
for edge in edges:
node_a, node_b = edge[0], edge[1]
streetmap.add_edge(node_a, node_b)
# exclude bi-directional edges when street is oneway
if not graph.edges[edge]['oneway']:
streetmap.add_edge(node_b, node_a)
streetmap.purge()
# returns streetmap
return streetmap
def test_path4_dist_inc():
map_con = InMemMap("mymap",
graph={
"A": ((1, 1), ["B", "C", "X"]),
"B": ((1, 3), ["A", "C", "D", "K"]),
"C": ((2, 2), ["A", "B", "D", "E", "X", "Y"]),
"D": ((2, 4), ["B", "C", "D", "E", "K", "L"]),
"E": ((3, 3), ["C", "D", "F", "Y"]),
"F": ((3, 5), ["D", "E", "L"]),
"X": ((2, 0), ["A", "C", "Y"]),
"Y": ((3, 1), ["X", "C", "E"]),
"K": ((1, 5), ["B", "D", "L"]),
"L": ((2, 6), ["K", "D", "F"])
},
use_latlon=False)
path = [(0.8, 0.7), (0.9, 0.7), (1.1, 1.0), (1.2, 1.5), (1.2, 1.6),
(1.1, 2.0), (1.1, 2.3), (1.3, 2.9), (1.2, 3.1), (1.5, 3.2),
(1.8, 3.5), (2.0, 3.7), (2.3, 3.5), (2.4, 3.2), (2.6, 3.1),
(2.9, 3.1), (3.0, 3.2), (3.1, 3.8), (3.0, 4.0), (3.1, 4.3),
(3.1, 4.6), (3.0, 4.9)]
matcher = DistanceMatcher(map_con,
max_dist=2,
obs_noise=1,
min_prob_norm=0.5)
matcher.match(path[:5])
if directory:
from leuvenmapmatching import visualization as mmviz
mmviz.plot_map(map_con,
matcher=matcher,
show_labels=True,
show_matching=True,
show_graph=True,
filename=str(directory / "test_path4_dist_inc_1.png"))
matcher.match(path, expand=True)
nodes = matcher.path_pred_onlynodes
if directory:
from leuvenmapmatching import visualization as mmviz
mmviz.plot_map(map_con,
matcher=matcher,
show_labels=True,
show_matching=True,
show_graph=True,
filename=str(directory / "test_path4_dist_inc_2.png"))
nodes_sol = ['X', 'A', 'B', 'D', 'E', 'F']
assert nodes == nodes_sol, "Nodes not equal:\n{}\n{}".format(
nodes, nodes_sol)
def setup_map():
path1 = [(1.8, 0.1), (1.8, 3.5), (3.0, 4.9)] # More nodes than observations
path2 = [(1.8, 0.1), (1.8, 2.0), (1.8, 3.5), (3.0, 4.9)]
path_sol = ['X', 'C', 'D', 'F']
mapdb = InMemMap("map", graph={
"A": ((1, 1), ["B", "C", "X"]),
"B": ((1, 3), ["A", "C", "D", "K"]),
"C": ((2, 2), ["A", "B", "D", "E", "X", "Y"]),
"D": ((2, 4), ["B", "C", "E", "K", "L", "F"]),
"E": ((3, 3), ["C", "D", "F", "Y"]),
"F": ((3, 5), ["D", "E", "L"]),
"X": ((2, 0), ["A", "C", "Y"]),
"Y": ((3, 1), ["X", "C", "E"]),
"K": ((1, 5), ["B", "D", "L"]),
"L": ((2, 6), ["K", "D", "F"])
}, use_latlon=False)
return mapdb, path1, path2, path_sol
def make_map(graph):
graph_proj = ox.project_graph(graph)
map_con = InMemMap("myosm",
use_latlon=True,
use_rtree=True,
index_edges=True)
nodes, _ = ox.graph_to_gdfs(graph_proj, nodes=True, edges=True)
nodes_proj = nodes.to_crs("EPSG:3395")
for nid, row in nodes_proj.iterrows():
map_con.add_node(nid, (row['lat'], row['lon']))
# adding edges using networkx graph
for nid1, nid2, _ in graph.edges:
map_con.add_edge(nid1, nid2)
map_con.purge()
return map_con
def make_map(graph, latlon=True, index_edges=True):
map_con = InMemMap(
"athensmap",
use_latlon=latlon,
index_edges=index_edges,
use_rtree=True) # Deprecated crs style in algorithm
nodes_proj, edges_proj = ox.graph_to_gdfs(graph,
nodes=True,
edges=True)
for nid, row in nodes_proj[['y', 'x']].iterrows():
map_con.add_node(nid, (row['y'], row['x']))
for nid, row in edges_proj[['u', 'v']].iterrows():
map_con.add_edge(row['u'], row['v'])
return map_con
def test_bug1():
dist = 10
nb_steps = 20
map_con = InMemMap("map", graph={
"A": ((1, dist), ["B"]),
"B": ((2, dist), ["A", "C", "CC"]),
"C": ((3, 0), ["B", "D"]),
"D": ((4 + dist, 0), ["C", "E"]),
"CC": ((3, 2 * dist), ["B", "DD"]),
"DD": ((4 + dist, 2 * dist), ["CC", "E"]),
"E": ((5 + dist, dist), ["F", "D", "DD"]),
"F": ((6 + dist, dist), ["E", ]),
}, use_latlon=False)
i = 10
path = [(1.1, 2*dist*i/nb_steps),
(2.1, 2*dist*i/nb_steps),
(5.1+dist, 2*dist*i/nb_steps),
(6.1+dist, 2*dist*i/nb_steps)
# (1, len*i/nb_steps),
# (2, len*i/nb_steps),
# (3, len*i/nb_steps)
]
matcher = SimpleMatcher(map_con, max_dist=dist + 1, obs_noise=dist + 1, min_prob_norm=None,
non_emitting_states=True)
nodes = matcher.match(path, unique=False)
print("Solution: ", nodes)
if directory:
import leuvenmapmatching.visualization as mm_vis
matcher.print_lattice()
matcher.print_lattice_stats()
mm_vis.plot_map(map_con, path=path, nodes=nodes, counts=matcher.node_counts(),
show_labels=True, filename=str(directory / "test_bugs_1.png"))
def example2():
path = [(1, 0), (7.5, 0.65), (10.1, 1.9)]
mapdb = InMemMap("mymap",
graph={
"A": ((1, 0.00), ["B"]),
"B": ((3, 0.00), ["A", "C"]),
"C": ((4, 0.70), ["B", "D"]),
"D": ((5, 1.00), ["C", "E"]),
"E": ((6, 1.00), ["D", "F"]),
"F": ((7, 0.70), ["E", "G"]),
"G": ((8, 0.00), ["F", "H"]),
"H": ((10, 0.0), ["G", "I"]),
"I": ((10, 2.0), ["H"])
},
use_latlon=False)
matcher = DistanceMatcher(mapdb,
max_dist_init=0.2,
obs_noise=1,
obs_noise_ne=10,
non_emitting_states=True,
only_edges=True)
states, _ = matcher.match(path)
nodes = matcher.path_pred_onlynodes
print("States\n------")
print(states)
print("Nodes\n------")
print(nodes)
print("")
matcher.print_lattice_stats()
mmviz.plot_map(mapdb,
matcher=matcher,
show_labels=True,
show_matching=True,
filename="output.png")
def mk_map(graph_proj):
map_con = InMemMap("myosm",
use_latlon=True,
use_rtree=True,
index_edges=True)
#Create GeoDataFrames
nodes_proj, edges_proj = ox.graph_to_gdfs(graph_proj,
nodes=True,
edges=True)
#좌표계 변경
nodes_proj = nodes_proj.to_crs({'init': 'epsg:4326'})
edges_proj = edges_proj.to_crs({'init': 'epsg:4326'})
for nid, row in nodes_proj[['lon', 'lat']].iterrows():
map_con.add_node(nid, (row['lat'], row['lon']))
for nid, row in edges_proj[['u', 'v']].iterrows():
map_con.add_edge(row['u'], row['v'])
return map_con
# graph = ox.graph_from_point((40.00792367,116.29994668),distance=3000,network_type='drive_service')
# graph_proj = ox.project_graph(graph)
# G_project_file=open('G_project.pickle','wb')
# pickle.dump(graph,G_project_file)
# G_project_file.close()
# Create GeoDataFrames
file=open('G_project.pickle','rb')
graph_proj = pickle.load(file)
nodes_proj, edges_proj = ox.graph_to_gdfs(graph_proj, nodes=True, edges=True)
map_con = InMemMap("myosm", use_rtree=True, index_edges=True)
for nid, row in nodes_proj[['x', 'y']].iterrows():
map_con.add_node(int(nid), (row['x'], row['y']))
for nid, row in edges_proj[['u', 'v']].iterrows():
map_con.add_edge(row['u'], row['v'])
map_con.purge()
# from leuvenmapmatching.util.gpx import gpx_to_path
# #track = gpx_to_path("mytrack.gpx")
# matcher = DistanceMatcher(map_con,
# max_dist=0.8,
# max_dist_init=25, # meter
# min_prob_norm=0.01,
# #non_emitting_length_factor=0.75,
trj_ids[i], map_con.graph[nodes[j]][0][0],
map_con.graph[nodes[j]][0][1]
]
output.write('{}\n'.format(str(trj_data)))
print(i)
# def plot_route(map_con, matcher, filename="my_plot.png", use_osm=True):
# mmviz.plot_map(map_con, matcher=matcher[1],
# use_osm=use_osm, zoom_path=True,
# show_labels=False, show_matching=True, show_graph=False,
# filename=filename)
if __name__ == "__main__":
map_con = InMemMap("osmmap",
use_latlon=True,
use_rtree=True,
index_edges=True)
graph = ox.load_graphml("mynetwork.graphml")
graph_proj = ox.project_graph(graph)
# Create GeoDataFrames
# Approach 2
print("start1")
nodes, edges = ox.graph_to_gdfs(graph_proj, nodes=True, edges=True)
nodes_proj = nodes.to_crs("EPSG:3414")
edges_proj = edges.to_crs("EPSG:3414")
for nid, row in nodes_proj.iterrows():
map_con.add_node(nid, (row['lat'], row['lon']))
from leuvenmapmatching.matcher.distance import DistanceMatcher
from leuvenmapmatching.map.inmem import InMemMap
from leuvenmapmatching import visualization as mmviz
path = [(1, 0), (7.5, 0.65), (10.1, 1.9)]
mapdb = InMemMap("mymap", graph={
"A": ((1, 0.00), ["B"]),
"B": ((3, 0.00), ["A", "C"]),
"C": ((4, 0.70), ["B", "D"]),
"D": ((5, 1.00), ["C", "E"]),
"E": ((6, 1.00), ["D", "F"]),
"F": ((7, 0.70), ["E", "G"]),
"G": ((8, 0.00), ["F", "H"]),
"H": ((10, 0.0), ["G", "I"]),
"I": ((10, 2.0), ["H"])
}, use_latlon=False)
matcher = DistanceMatcher(mapdb, max_dist_init=0.2, obs_noise=1, obs_noise_ne=10,
non_emitting_states=True, only_edges=True)
states, _ = matcher.match(path)
nodes = matcher.path_pred_onlynodes
print("States\n------")
print(states)
print("Nodes\n------")
print(nodes)
print("")
matcher.print_lattice_stats()
mmviz.plot_map(mapdb, matcher=matcher,
show_labels=True, show_matching=True
filename="output.png")
def test_path2_inc():
path = [(0.8, 0.7), (0.9, 0.7), (1.1, 1.0), (1.2, 1.5), (1.2, 1.6),
(1.1, 2.0), (1.1, 2.3), (1.3, 2.9), (1.2, 3.1), (1.5, 3.2),
(1.8, 3.5), (2.0, 3.7), (2.1, 3.3), (2.4, 3.2), (2.6, 3.1),
(2.9, 3.1), (3.0, 3.2), (3.1, 3.8), (3.0, 4.0), (3.1, 4.3),
(3.1, 4.6), (3.0, 4.9)]
# path_sol = ['A', ('A', 'B'), 'B', ('B', 'D'), 'D', ('D', 'E'), 'E', ('E', 'F')]
path_sol_nodes = ['A', 'B', 'D', 'E', 'F']
mapdb = InMemMap("map",
graph={
"A": ((1, 1), ["B", "C", "X"]),
"B": ((1, 3), ["A", "C", "D", "K"]),
"C": ((2, 2), ["A", "B", "D", "E", "X", "Y"]),
"D": ((2, 4), ["B", "C", "F", "E", "K", "L"]),
"E": ((3, 3), ["C", "D", "F", "Y"]),
"F": ((3, 5), ["D", "E", "L"]),
"X": ((2, 0), ["A", "C", "Y"]),
"Y": ((3, 1), ["X", "C", "E"]),
"K": ((1, 5), ["B", "D", "L"]),
"L": ((2, 6), ["K", "D", "F"])
},
use_latlon=False)
## Phase 1
print('=== PHASE 1 ===')
matcher = SimpleMatcher(mapdb,
max_dist=None,
min_prob_norm=0.001,
non_emitting_states=False,
only_edges=False,
max_lattice_width=1)
path_pred, _ = matcher.match(path, unique=True)
if directory:
matcher.print_lattice_stats()
matcher.print_lattice()
from leuvenmapmatching import visualization as mmviz
with (directory / 'test_path2_inc_1.gv').open('w') as ofile:
matcher.lattice_dot(file=ofile, precision=2, render=True)
mmviz.plot_map(mapdb,
matcher=matcher,
show_labels=True,
show_matching=True,
show_lattice=True,
show_graph=True,
filename=str(directory / "test_path2_inc_1.png"))
## Next phases
for phase_nb, phase_width in enumerate([2, 3]):
print(f'=== PHASE {phase_nb + 2} ===')
path_pred, _ = matcher.increase_max_lattice_width(phase_width,
unique=True)
if directory:
matcher.print_lattice_stats()
matcher.print_lattice()
from leuvenmapmatching import visualization as mmviz
with (directory /
f'test_path2_inc_{phase_nb + 2}.gv').open('w') as ofile:
matcher.lattice_dot(file=ofile, precision=2, render=True)
mmviz.plot_map(mapdb,
matcher=matcher,
show_labels=True,
show_matching=True,
show_lattice=True,
show_graph=True,
filename=str(directory /
f"test_path2_inc_{phase_nb + 2}.png"))
# assert path_pred == path_sol, "Nodes not equal:\n{}\n{}".format(path_pred, path_sol)
nodes_pred = matcher.path_pred_onlynodes
assert nodes_pred == path_sol_nodes, f"Nodes not equal:\n{nodes_pred}\n{path_sol_nodes}"