def test_path1():
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 = SimpleMatcher(mapdb, max_dist=None, min_prob_norm=None,
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_path1.png"))
# assert path_pred == path_sol, f"Paths not equal:\n{path_pred}\n{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_path3():
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 = SimpleMatcher(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:
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_path3.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_path2():
mapdb, path1, path2, path_sol = setup_map()
matcher = SimpleMatcher(mapdb, max_dist_init=1, min_prob_norm=0.5, obs_noise=0.5,
non_emitting_states=True, only_edges=False)
matcher.match(path2, unique=True)
path_pred = matcher.path_pred_onlynodes
if directory:
from leuvenmapmatching import visualization as mmviz
matcher.print_lattice_stats()
matcher.print_lattice()
with (directory / 'lattice_path2.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_nonemitting_test_path2.png"))
assert path_pred == path_sol, "Nodes not equal:\n{}\n{}".format(path_pred, path_sol)
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_path1_inc():
mapdb, path1, path2, path_sol = setup_map()
matcher = SimpleMatcher(mapdb,
max_dist_init=1,
in_prob_norm=0.5,
obs_noise=0.5,
non_emitting_states=True,
only_edges=False,
max_lattice_width=1)
print('## PHASE 1 ##')
matcher.match(path1, unique=True)
path_pred = matcher.path_pred_onlynodes
if directory:
from leuvenmapmatching import visualization as mmviz
matcher.print_lattice_stats()
matcher.print_lattice()
with (directory / 'lattice_path1_inc1.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_graph=True,
filename=str(directory /
"test_nonemitting_test_path1_inc1.png"))
print('## PHASE 2 ##')
matcher.increase_max_lattice_width(3, unique=True)
path_pred = matcher.path_pred_onlynodes
if directory:
from leuvenmapmatching import visualization as mmviz
matcher.print_lattice_stats()
matcher.print_lattice()
with (directory / 'lattice_path1_inc2.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_graph=True,
filename=str(directory /
"test_nonemitting_test_path1_inc2.png"))
assert path_pred == path_sol, f"Nodes not equal:\n{path_pred}\n{path_sol}"
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 test_path3_many_obs():
path = [(1, 0), (3, -0.1), (3.7, 0.6), (4.5, 0.7), (5.5, 1.2), (6.5, 0.88),
(7.5, 0.65), (8.5, -0.1), (9.8, 0.1), (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)
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,
show_graph=True,
show_lattice=True,
filename=str(directory / "test_test_path_ne_3_mo.png"))
assert path_pred == path_sol, f"Nodes not equal:\n{path_pred}\n{path_sol}"
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}"