OpenStreetMap中GPS坐标与Way ID匹配及道路类型查询问题

Got it, let's tackle this problem step by step. You've got GPS points from vehicles on public roads, and an OSM .osm file—you need to map each point to its corresponding road type. Here's how to do it effectively:

OSM stores roads as <way> elements, each linked to geographic nodes (<nd> tags) and tagged with a highway attribute that defines the road type (e.g., motorway, residential, service). The core task is to:

1. Extract road geometries and their highway tags from your .osm file
2. Match each GPS coordinate to the nearest/most relevant road
3. Pull the corresponding road type tag for each point

This is the most efficient approach if you have thousands/millions of GPS points—PostGIS is built for fast spatial queries.

1. Set up your environment

   • Install PostGIS (with PostgreSQL) and osm2pgsql (a tool to import OSM data into PostGIS)
   • Create a database with PostGIS enabled:

     CREATE DATABASE osm_roads;
     \c osm_roads;
     CREATE EXTENSION postgis;
     

2. Import your OSM file
   Run this command to load your .osm data into the database (the --slim flag helps with larger files):

   osm2pgsql -d osm_roads -U your_db_user --slim your_map.osm
   

   This creates a planet_osm_roads table with columns like highway (road type) and way (the road's spatial geometry).

3. Import your GPS points
   Create a table for your GPS data, then load your coordinates (example for CSV input):

   CREATE TABLE gps_points (
       id SERIAL PRIMARY KEY,
       lat NUMERIC,
       lon NUMERIC,
       geom GEOMETRY(Point, 4326)
   );
   
   -- Insert data (replace with your CSV path)
   COPY gps_points(lat, lon) FROM '/path/to/your/gps.csv' WITH (FORMAT CSV, HEADER);
   
   -- Generate spatial geometry for each point
   UPDATE gps_points SET geom = ST_SetSRID(ST_MakePoint(lon, lat), 4326);
   

4. Run the spatial match query
   Use PostGIS spatial functions to find the nearest road for each GPS point (adjust the distance threshold based on your GPS accuracy—0.0001 degrees ≈ 10 meters):

   SELECT
       g.id,
       g.lat,
       g.lon,
       COALESCE(r.highway, 'unmatched') AS road_type,
       ST_Distance(g.geom, r.way) AS distance_to_road
   FROM gps_points g
   LEFT JOIN LATERAL (
       SELECT highway, way
       FROM planet_osm_roads
       WHERE ST_DWithin(g.geom, way, 0.0001)
       ORDER BY ST_Distance(g.geom, way)
       LIMIT 1
   ) r ON true
   ORDER BY g.id;
   

   This returns each GPS point with its matched road type, or unmatched if no road is within the threshold.

If you prefer code over databases, use Python libraries like osmnx, geopandas, and shapely for a lightweight workflow.

1. Install dependencies

   pip install osmnx geopandas shapely pandas
   

2. Load and process OSM + GPS data

   import geopandas as gpd
   from shapely.geometry import Point
   import osmnx as ox
   
   # Load roads from your OSM file and convert to GeoDataFrame
   road_graph = ox.graph_from_xml("your_map.osm", simplify=False)
   roads_gdf = ox.graph_to_gdfs(road_graph, nodes=False, edges=True)
   # Keep only relevant columns: road type and geometry
   roads_gdf = roads_gdf[["highway", "geometry"]].set_crs(epsg=4326)
   
   # Load your GPS points (replace with your data source)
   gps_df = gpd.read_csv("your_gps_points.csv")
   # Create spatial geometry for each GPS point
   gps_df["geometry"] = gps_df.apply(lambda row: Point(row.lon, row.lat), axis=1)
   gps_df = gps_df.set_crs(epsg=4326)
   
   # Match each GPS point to the nearest road
   # Adjust max_distance to match your GPS accuracy (0.0001 ≈ 10 meters)
   matched_df = gpd.sjoin_nearest(
       gps_df, roads_gdf, how="left", max_distance=0.0001, distance_col="distance_to_road"
   )
   
   # Save the result with road types
   matched_df[["id", "lat", "lon", "highway"]].to_csv("gps_with_road_types.csv", index=False)
   

• OSM highway tag values: Common types include motorway, trunk, primary, secondary, residential, service, and footway. Filter or map these based on your needs.
• GPS accuracy: Adjust the distance threshold in your queries—if your GPS has 5-meter error, use a smaller threshold (e.g., 0.00005 degrees) to avoid matching to wrong roads.
• Large OSM files: For huge .osm exports, osm2pgsql is more reliable than Python libraries, as it handles memory usage better.
• Unmatched points: If some GPS points don't match any road, check if they're off-road (valid) or if your OSM file doesn't cover that area.

内容的提问来源于stack exchange，提问作者Erhan