Leuven.MapMatching

Alternatively, you can use osmnx to retrieve a graph for a specific place and populate InMemMap. There are two primary approaches:

Approach 1: Using projected GeoDataFrames Retrieve a projected graph, convert it to GeoDataFrames, and add nodes/edges using the projected coordinates.

Approach 2: Using unprojected GeoDataFrames or NetworkX Convert GeoDataFrames to a specific CRS (e.g., EPSG:3395) to access lat/lon for nodes, or iterate directly through the networkx graph edges to add them to the map.

import osmnx as ox
# ... setup map_con ...

graph = ox.graph_from_place('Leuven, Belgium', network_type='drive', simplify=False)
graph_proj = ox.project_graph(graph)

# Approach 1
nodes_proj, edges_proj = ox.graph_to_gdfs(graph_proj, nodes=True, edges=True)
for nid, row in nodes_proj[['x', 'y']].iterrows():
    map_con.add_node(nid, (row['x'], row['y']))
for eid, _ in edges_proj.iterrows():
    map_con.add_edge(eid[0], eid[1])

# Approach 2
nodes, edges = ox.graph_to_gdfs(graph_proj, nodes=True, edges=True)
nodes_proj = nodes.to_crs("EPSG:3395")
edges_proj = edges.to_crs("EPSG:3395")
for nid, row in nodes_proj.iterrows():
    map_con.add_node(nid, (row['lat'], row['lon']))

# Extract edges directly from networkx graph
for nid1, nid2, _ in graph.edges:
    map_con.add_edge(nid1, nid2)

To improve performance, you can transform latitude-longitude coordinates into a Cartesian (X-Y) coordinate system. This can be done using the built-in to_xy() method on a Map instance or by using external tools like pyproj.

Using Leuven.MapMatching to_xy()

You can create a new map instance projected to X-Y and then convert your GPS route points using latlon2yx().

Using pyproj

You can use pyproj to project coordinates manually. Note on Coordinate Order: pyproj typically uses (longitude, latitude) (x-y convention), whereas Leuven.MapMatching follows ISO 6709 and uses (latitude, longitude). If using pyproj, you may need to use the axisswap option to align with the toolbox's expected order.

from leuvenmapmatching.map.inmem import InMemMap

# 1. Create a lat-lon map
map_con_latlon = InMemMap("myosm", use_latlon=True)

# 2. Project to X-Y
map_con_xy = map_con_latlon.to_xy()

# 3. Convert GPS route points
route_latlon = [(50.864, 4.67878), (50.86381, 4.68054)] # (lat, lon)
route_xy = [map_con_xy.latlon2yx(latlon) for latlon in route_latlon]

To build an in-memory map from an OSM XML file, use osmread to parse the file and InMemMap to store the nodes and edges.

When iterating through osmread.Way entities, you can filter for specific tags (like highway) and add edges. To handle one-way roads as two-way for the matcher, you should add the edge in both directions (node_a to node_b and node_b to node_a).

from leuvenmapmatching.map.inmem import InMemMap
import osmread

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()

The matcher.lattice contains all possible paths through the lattice. It is a dictionary where each key is an observation index and each value is a LatticeColumn object.

Accessing Matches

For a specific observation, you can retrieve all possible Matching objects using matcher.lattice[index].values_all().

Backtracking through the Lattice

You can backtrack from the end of a path to find the sequence of matches. To find the best match for the final element, you can use max() on the values with the logprob attribute as the key:

# Find the best match for the last element
m = max(matcher.lattice[len(path)-1].values_all(), key=lambda m: m.logprob)

Once you have a Matching object m, you can inspect its connections to previous steps:

• m.prev: Returns a set containing the best previous match(es) with a connection (multiple if they have equal probability).
• m.prev_other: Returns a set of all previous matches in the lattice that have a connection to the current match.

>>> matcher.lattice
{0: <leuvenmapmatching.matcher.base.LatticeColumn at 0x12369bf40>,
 1: <leuvenmapmatching.matcher.base.LatticeColumn at 0x123639dc0>,
 ...}

>>> matcher.lattice[0].values_all()
{Matching<A-B-0-0>,
 Matching<A-B-0-1>,
 Matching<A-C-0-0>,
 ...}

>>> # Find best match for the last element
>>> m = max(matcher.lattice[len(path)-1].values_all(), key=lambda m: m.logprob)
>>> m.logprob
-0.6835815469734807

>>> m.prev  # Best previous match with a connection
{Matching<E-F-20-0>}
>>> m.prev_other  # All previous matches in the lattice with a connection
{Matching<C-E-20-0>,
 Matching<D-E-20-0>,
 Matching<F-E-20-0>,
 Matching<Y-E-20-0>}