lanestyle

Lane-level road maps from Python.
Every lane drawn at its real width, with painted lane lines, turns, and a click that shows where a lane leads. One offline HTML file.

Install · Quickstart · Gallery · What goes in · Documentation

Why lanestyle

• Lanes, not roads. Each lane is its own line, exactly its width in metres from zoom 16 on (3.25 m where OSM says nothing), so neighbours sit side by side with no gap and no overlap.
• Painted lane lines. Dashed dividers between lanes of one direction, a solid centre line between the two directions, grey edges: drawn to scale, cut at junctions, styled per type.
• Turns you can see. Click a lane: it turns red, the lanes it leads into green, U-turns purple. Every lane carries its turn label (left + thru, right, fork, merge, end).
• Built on roadstyle. Bridges over, tunnels under (from the OSM layer tag), base maps, the filter box, popups, arrows and the rs* JavaScript API come with it. lanestyle is to lanes what mapstyle is to the full base map.
• From OpenStreetMap. duckOSM places the lanes and works out the lane-to-lane turns as a GMNS database; from_gmns reads it. Any other lane table draws too.
• One offline file. Map, data and styling in a single HTML page: open it, serve it, embed it.

Install

pip install lanestyle

Python ≥ 3.10. Brings roadstyle ≥ 0.11 (line widths in metres), geopandas, shapely 2, duckdb and pandas.

Quickstart

No data needed. Monaco's lanes ship with the repo as GeoParquet (docs/data/, 1 MB):

import geopandas as gpd, pandas as pd
import lanestyle as ls

lanes = gpd.read_parquet("docs/data/monaco_lanes.parquet")
turns = pd.read_parquet("docs/data/monaco_turns.parquet")
ls.render_lanes(lanes, turns=turns).save("monaco.html")     # open it: no server needed

Your own area, with duckOSM (pip install "duckosm @ git+https://github.com/Khoshkhah/duckOSM"):

duckosm build --pbf monaco-latest.osm.pbf -o monaco.duckdb -m driving
duckosm gmns monaco.duckdb -m driving -o monaco_gmns.duckdb

lanes, turns = ls.from_gmns("monaco_gmns.duckdb", source_db="monaco.duckdb")   # + levels, boundary
ls.render_lanes(lanes, turns=turns, boundary=ls.read_boundary("monaco.duckdb")).save("monaco.html")

Or from the shell: python render_lanes.py monaco_gmns.duckdb monaco.html --source-db monaco.duckdb. The whole chain from a raw .osm.pbf: From OSM to lanes.

More looks: every roadstyle keyword passes through.

ls.render_lanes(lanes, turns=turns, basemap="dark_matter")                              # dark
ls.render_lanes(lanes, turns=turns, settings={"lanes": {"colors": {"bus": "#d35400"}}})  # your colours
ls.render_lanes(lanes, settings={"lanes": {"lines": False, "type_label_zoom": None}})     # plain lanes
ls.render_lanes(lanes, turns=turns, overlays=[rs.Overlay(route_gdf, label="route")])     # a lane route on top

Gallery

Lane lines dividers, centre line, edges, to scale	A roundabout one ring, one road	A tunnel under the street, from the layer tag
Bus lanes painted over the palette, a row in the Roads box	Click a lane red, into green, U-turns purple	Zoomed out roadstyle's class widths below zoom 16

Every look with its code: the gallery.

What goes in

lanes is a GeoDataFrame, one row per lane, each line in the direction of travel. Three columns are required; the others switch features on:

turns (optional) has from_lane, to_lane and a type (thru, left, right, uturn, diverge, merge): the click colours, the lane type labels, and turns_in / turns_out in the popup. Lane 1 is the leftmost lane (right-hand traffic). Details: The lane table.

Settings

roadstyle's settings apply as they are; lanestyle adds a lanes key (defaults): the lane and click colours, the three lane line types (color, width_m, dash_m), junction_trim_m, type_label_zoom, default_width_m, width_m_zoom. Override them the roadstyle way, a lanestyle.json in the current folder or settings={"lanes": {...}}, stating only what changes.

Drive it from JavaScript

A lanestyle page is a roadstyle page, so the whole window.rs* API is there, with the lane table's columns as properties:

const bus = rsQuery(p => p.use === "bus");  rsColor(bus, "#ff8800");  rsFocus(bus);
rsSelect(rsQuery(p => p.lane_id === "8121729169906061189_2")[0]);     // click a lane by id

Fidelity

Lane geometry is duckOSM's drive-side offset centre line, one continuous curve along a road. Widths are the 3.25 m default wherever OSM lacks width:lanes, which today is nearly everywhere. Lane-to-lane turns follow turn:lanes where tagged and osm2gmns's defaults elsewhere. A lane-level map, not a survey-grade HD map.

Documentation

khoshkhah.github.io/lanestyle: get started, guides (the lane table, lane lines, turns and clicks, the duckOSM pipeline, websites), the gallery, the Python API, settings, the command line, and the design notes.

License

MIT.