How to extract from_osm_id, to_osm_id, and speed for --segment-speed-file in OSRM?

[abhishekkushwaha-fareye]

I’m trying to use osrm-customize with --segment-speed-file to apply custom speeds to OSM road segments. However, I need help extracting the required data (from_osm_id, to_osm_id, and speed) from OSM XML/PBF files.
my osm file looks like this:

<way id="486802566" version="1" timestamp="2024-11-12T00:00:00Z">
  <nd ref="5317195167"/>
  <nd ref="3524650640"/>
  <nd ref="5229338522"/>
  <nd ref="3085320160"/>
  <nd ref="6424292322"/>
  <nd ref="4174899249"/>
  <nd ref="3419227097"/> 
  <!-- More nodes... -->  
  <tag k="highway" v="residential"/>  
  <tag k="maxspeed" v="30"/>  
</way>  

What I Need

from_osm_id & to_osm_id:
Should these be consecutive node pairs (e.g., 5317195167 -> 3524650640 ,3524650640 -> 5229338522 ,5229338522 -> 3085320160 ,3085320160 -> 6424292322 ,6424292322 -> 4174899249 ,4174899249 -> 3419227097 ) from the way’s elements?
Or is there another standard (e.g., way IDs + node positions)?
speed:
Should I prioritize maxspeed tags, or fall back to highway type defaults?
How to handle missing/ambiguous speeds (e.g., mph vs. km/h)?

[drogers0]

To my knowledge you can not easily do this soley with OSRM.
I wrote some code a while ago to extract all from_osm_id & to_osm_id (aka u & v pairs aka edges). It uses the python packages pyrosm and osmnx.
I was using it to bulk map gps coordinates and update speeds, which is why I create a polygon of each edge, so I can easily sjoin later. It loads in the whole graph so the bigger your osm file the slower it will go (use osmosis to parse down osm file first.

A better solution for more targeted queries is probably the Overpass API (you can also run your own).

I am not totally sure what your speed question is, but I am guessing the answer is that it depends on your use case and default is km/h

The python code

from pyrosm import OSM
import osmnx as ox
from shapely.geometry import Point, Polygon
from shapely import wkt
import folium
import geopandas as gpd
import pandas as pd

'''
# example usage:
graph = osm_utils.get_graph(protobuf_file)
edges = osm_utils.get_edges(graph, polygon)
ways = osm_utils.get_ways(edges)
edges.to_csv(edge_file, index=False)
ways.to_csv(ways_file, index=False)
edges = osm_utils.read_geo_csv(edge_file, ['geometry','polygon'], 'polygon')
ways = osm_utils.read_geo_csv(ways_file, ['geometry'], 'geometry')
osm_utils.plot_ways(ways)
'''


def polygonize(x, buffer_size=0.0002):
    return x.buffer(buffer_size, quad_segs=2)


def combine_polygons(x):
    polygon = x['polygon'].unary_union
    if polygon.geom_type == 'MultiPolygon':
        polygon = Polygon(polygon.convex_hull.exterior.coords)
    return polygon


def get_graph(protobuf_file, undirected=False):
    osm = OSM(protobuf_file)
    nodes, edges = osm.get_network(nodes=True, network_type='driving')
    graph = osm.to_graph(nodes, edges, graph_type='networkx', retain_all=True)

    hwy_speeds = {"residential": 35, "secondary": 50, "tertiary": 60}

    # impute speed on all edges missing data
    graph = ox.add_edge_speeds(graph, hwy_speeds=hwy_speeds)

    # calculate travel time (seconds) for all edges
    graph = ox.add_edge_travel_times(graph)

    # add edge bearings
    graph = ox.add_edge_bearings(graph)

    if undirected:
        graph = ox.convert.to_undirected(graph)
    return graph


def get_edges(graph, polygon=None, maintain_ways=True):
    '''
        returns ['u', 'v', 'key', 'access', 'area', 'bicycle', 'bicycle_road',
       'bridge', 'busway', 'cycleway', 'est_width', 'foot', 'footway',
       'highway', 'junction', 'lanes', 'lit', 'maxspeed', 'motorcar',
       'motor_vehicle', 'name', 'oneway', 'overtaking', 'psv', 'ref',
       'service', 'segregated', 'sidewalk', 'smoothness', 'surface',
       'tracktype', 'tunnel', 'turn', 'width', 'osmid', 'timestamp', 'version',
       'tags', 'osm_type', 'geometry', 'length', 'speed_kph', 'travel_time',
       'bearing', 'osmid_u', 'x_u', 'y_u', 'osmid_v', 'x_v', 'y_v', 'polygon']
    '''

    nodes, edges = ox.graph_to_gdfs(graph, nodes=True)
    nodes.reset_index(drop=True, inplace=True)
    edges.reset_index(inplace=True)

    for i in ['u', 'v']:
        edges = edges.merge(
            nodes[['osmid', 'x', 'y']],
            how='left',
            left_on=i,
            right_on='osmid',
            suffixes=('', f'_{i}')
        ).rename(columns={'x': f'x_{i}', 'y': f'y_{i}'}, errors='ignore')

    if polygon is not None:
        # Remove edges/ways that have all u and v nodes outside the polygon
        def either_inside(row):
            return polygon.contains(Point(row['y_u'], row['x_u'])) or \
                   polygon.contains(Point(row['y_v'], row['x_v']))

        edges['edge_in_polygon'] = edges[['x_u', 'y_u', 'x_v', 'y_v']].apply(
            either_inside, axis=1
        )
        edges['way_in_polygon'] = edges.groupby('osmid')['edge_in_polygon'] \
            .transform('any')

        if maintain_ways:
            edges = edges[edges['way_in_polygon']]
        else:
            edges = edges[edges['edge_in_polygon']]

    edges['polygon'] = edges['geometry'].apply(polygonize)

    return edges
    ```
</details>