lanestyle 0.1.0__tar.gz

lanestyle-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kaveh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lanestyle-0.1.0/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: lanestyle
+Version: 0.1.0
+Summary: Lane-level road maps on roadstyle: every lane drawn at its real width, with lane lines, turns and a click-to-see-connectivity view, from a lane table or a duckOSM GMNS database
+Author: Kaveh
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Khoshkhah/lanestyle
+Project-URL: Repository, https://github.com/Khoshkhah/lanestyle
+Project-URL: Issues, https://github.com/Khoshkhah/lanestyle/issues
+Project-URL: roadstyle, https://github.com/Khoshkhah/roadstyle
+Project-URL: duckOSM, https://github.com/Khoshkhah/duckOSM
+Keywords: lanes,lane-level map,GMNS,OpenStreetMap,roadstyle,duckOSM,MapLibre,traffic
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: roadstyle>=0.11
+Requires-Dist: geopandas
+Requires-Dist: shapely>=2
+Requires-Dist: duckdb
+Requires-Dist: pandas
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/logo.svg" alt="lanestyle logo" width="96">
+</p>
+
+<h1 align="center">lanestyle</h1>
+
+<p align="center">
+  <b>Lane-level road maps from Python.</b><br>
+  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.
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/lanestyle/"><img src="https://img.shields.io/pypi/v/lanestyle.svg" alt="PyPI"></a>
+  <a href="https://github.com/Khoshkhah/lanestyle/actions/workflows/test.yml"><img src="https://github.com/Khoshkhah/lanestyle/actions/workflows/test.yml/badge.svg?branch=master" alt="Tests"></a>
+  <a href="https://khoshkhah.github.io/lanestyle/"><img src="https://img.shields.io/badge/docs-khoshkhah.github.io%2Flanestyle-3f51b5.svg" alt="Docs"></a>
+  <img src="https://img.shields.io/badge/python-3.10%2B-3776AB.svg" alt="Python 3.10+">
+  <a href="https://github.com/Khoshkhah/lanestyle/blob/master/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License: MIT"></a>
+</p>
+
+<p align="center">
+  <a href="#install">Install</a> ·
+  <a href="#quickstart">Quickstart</a> ·
+  <a href="#gallery">Gallery</a> ·
+  <a href="#what-goes-in">What goes in</a> ·
+  <a href="https://khoshkhah.github.io/lanestyle/">Documentation</a>
+</p>
+
+![A lanestyle map of Monaco: Boulevard des Moulins with its bus lane in blue, dashed dividers, turn labels on every lane and a roundabout](https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/hero.jpg)
+
+## 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](https://github.com/Khoshkhah/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](https://github.com/Khoshkhah/mapstyle) is to the
+  full base map.
+- **From OpenStreetMap.** [duckOSM](https://github.com/Khoshkhah/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
+
+```bash
+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/`](docs/data), 1 MB):
+
+```python
+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"`):
+
+```bash
+duckosm build --pbf monaco-latest.osm.pbf -o monaco.duckdb -m driving
+duckosm gmns monaco.duckdb -m driving -o monaco_gmns.duckdb
+```
+
+```python
+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](https://khoshkhah.github.io/lanestyle/pipeline/).
+
+**More looks:** every roadstyle keyword passes through.
+
+```python
+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
+
+<table>
+<tr>
+<td width="33%" valign="top"><a href="https://khoshkhah.github.io/lanestyle/gallery/"><img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/gallery/lane_lines.jpg" alt="Lane lines" width="100%"></a><br><b>Lane lines</b><br><sub>dividers, centre line, edges, to scale</sub></td>
+<td width="33%" valign="top"><a href="https://khoshkhah.github.io/lanestyle/gallery/"><img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/gallery/roundabout.jpg" alt="A roundabout" width="100%"></a><br><b>A roundabout</b><br><sub>one ring, one road</sub></td>
+<td width="33%" valign="top"><a href="https://khoshkhah.github.io/lanestyle/gallery/"><img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/gallery/tunnel.jpg" alt="A tunnel" width="100%"></a><br><b>A tunnel</b><br><sub>under the street, from the <code>layer</code> tag</sub></td>
+</tr>
+<tr>
+<td width="33%" valign="top"><a href="https://khoshkhah.github.io/lanestyle/gallery/"><img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/gallery/bus_lane.jpg" alt="Bus lanes" width="100%"></a><br><b>Bus lanes</b><br><sub>painted over the palette, a row in the Roads box</sub></td>
+<td width="33%" valign="top"><a href="https://khoshkhah.github.io/lanestyle/gallery/"><img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/gallery/click.jpg" alt="Click a lane" width="100%"></a><br><b>Click a lane</b><br><sub>red, into green, U-turns purple</sub></td>
+<td width="33%" valign="top"><a href="https://khoshkhah.github.io/lanestyle/gallery/"><img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/gallery/overview.jpg" alt="Zoomed out" width="100%"></a><br><b>Zoomed out</b><br><sub>roadstyle's class widths below zoom 16</sub></td>
+</tr>
+</table>
+
+Every look with its code: **[the gallery](https://khoshkhah.github.io/lanestyle/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:
+
+| Column | Powers |
+|---|---|
+| `lane_id`, `geometry`, `highway` | the lane: unique id, centre line, road class (colour, filter box) |
+| `width_m` | its width in metres (3.25 where null) |
+| `use` | `auto`, `bus` or `bike`: bus and bike lanes are painted over the palette |
+| `bridge` / `tunnel` / `layer` | grade separation, read as roadstyle reads them |
+| `name` | the street label (set it on one lane per road) |
+| `link_id`, `lane_num` (+ `reverse_link_id`, `from_node_id`, `to_node_id`) | the lane lines: which lanes share a road, which road is the other direction, where junctions are |
+| `connector`, `from_lane`, `to_lane` | lane connectors: the curves through a junction, drawn like lanes |
+| anything else | shown in the popup |
+
+`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](https://khoshkhah.github.io/lanestyle/guides/lane-table/).
+
+## Settings
+
+roadstyle's settings apply as they are; lanestyle adds a `lanes` key
+([defaults](src/lanestyle/data/lanestyle.json)): 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:
+
+```js
+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](https://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.

lanestyle-0.1.0/README.md

@@ -0,0 +1,163 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/logo.svg" alt="lanestyle logo" width="96">
+</p>
+
+<h1 align="center">lanestyle</h1>
+
+<p align="center">
+  <b>Lane-level road maps from Python.</b><br>
+  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.
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/lanestyle/"><img src="https://img.shields.io/pypi/v/lanestyle.svg" alt="PyPI"></a>
+  <a href="https://github.com/Khoshkhah/lanestyle/actions/workflows/test.yml"><img src="https://github.com/Khoshkhah/lanestyle/actions/workflows/test.yml/badge.svg?branch=master" alt="Tests"></a>
+  <a href="https://khoshkhah.github.io/lanestyle/"><img src="https://img.shields.io/badge/docs-khoshkhah.github.io%2Flanestyle-3f51b5.svg" alt="Docs"></a>
+  <img src="https://img.shields.io/badge/python-3.10%2B-3776AB.svg" alt="Python 3.10+">
+  <a href="https://github.com/Khoshkhah/lanestyle/blob/master/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License: MIT"></a>
+</p>
+
+<p align="center">
+  <a href="#install">Install</a> ·
+  <a href="#quickstart">Quickstart</a> ·
+  <a href="#gallery">Gallery</a> ·
+  <a href="#what-goes-in">What goes in</a> ·
+  <a href="https://khoshkhah.github.io/lanestyle/">Documentation</a>
+</p>
+
+![A lanestyle map of Monaco: Boulevard des Moulins with its bus lane in blue, dashed dividers, turn labels on every lane and a roundabout](https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/hero.jpg)
+
+## 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](https://github.com/Khoshkhah/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](https://github.com/Khoshkhah/mapstyle) is to the
+  full base map.
+- **From OpenStreetMap.** [duckOSM](https://github.com/Khoshkhah/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
+
+```bash
+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/`](docs/data), 1 MB):
+
+```python
+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"`):
+
+```bash
+duckosm build --pbf monaco-latest.osm.pbf -o monaco.duckdb -m driving
+duckosm gmns monaco.duckdb -m driving -o monaco_gmns.duckdb
+```
+
+```python
+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](https://khoshkhah.github.io/lanestyle/pipeline/).
+
+**More looks:** every roadstyle keyword passes through.
+
+```python
+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
+
+<table>
+<tr>
+<td width="33%" valign="top"><a href="https://khoshkhah.github.io/lanestyle/gallery/"><img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/gallery/lane_lines.jpg" alt="Lane lines" width="100%"></a><br><b>Lane lines</b><br><sub>dividers, centre line, edges, to scale</sub></td>
+<td width="33%" valign="top"><a href="https://khoshkhah.github.io/lanestyle/gallery/"><img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/gallery/roundabout.jpg" alt="A roundabout" width="100%"></a><br><b>A roundabout</b><br><sub>one ring, one road</sub></td>
+<td width="33%" valign="top"><a href="https://khoshkhah.github.io/lanestyle/gallery/"><img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/gallery/tunnel.jpg" alt="A tunnel" width="100%"></a><br><b>A tunnel</b><br><sub>under the street, from the <code>layer</code> tag</sub></td>
+</tr>
+<tr>
+<td width="33%" valign="top"><a href="https://khoshkhah.github.io/lanestyle/gallery/"><img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/gallery/bus_lane.jpg" alt="Bus lanes" width="100%"></a><br><b>Bus lanes</b><br><sub>painted over the palette, a row in the Roads box</sub></td>
+<td width="33%" valign="top"><a href="https://khoshkhah.github.io/lanestyle/gallery/"><img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/gallery/click.jpg" alt="Click a lane" width="100%"></a><br><b>Click a lane</b><br><sub>red, into green, U-turns purple</sub></td>
+<td width="33%" valign="top"><a href="https://khoshkhah.github.io/lanestyle/gallery/"><img src="https://raw.githubusercontent.com/Khoshkhah/lanestyle/master/docs/img/gallery/overview.jpg" alt="Zoomed out" width="100%"></a><br><b>Zoomed out</b><br><sub>roadstyle's class widths below zoom 16</sub></td>
+</tr>
+</table>
+
+Every look with its code: **[the gallery](https://khoshkhah.github.io/lanestyle/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:
+
+| Column | Powers |
+|---|---|
+| `lane_id`, `geometry`, `highway` | the lane: unique id, centre line, road class (colour, filter box) |
+| `width_m` | its width in metres (3.25 where null) |
+| `use` | `auto`, `bus` or `bike`: bus and bike lanes are painted over the palette |
+| `bridge` / `tunnel` / `layer` | grade separation, read as roadstyle reads them |
+| `name` | the street label (set it on one lane per road) |
+| `link_id`, `lane_num` (+ `reverse_link_id`, `from_node_id`, `to_node_id`) | the lane lines: which lanes share a road, which road is the other direction, where junctions are |
+| `connector`, `from_lane`, `to_lane` | lane connectors: the curves through a junction, drawn like lanes |
+| anything else | shown in the popup |
+
+`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](https://khoshkhah.github.io/lanestyle/guides/lane-table/).
+
+## Settings
+
+roadstyle's settings apply as they are; lanestyle adds a `lanes` key
+([defaults](src/lanestyle/data/lanestyle.json)): 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:
+
+```js
+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](https://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.

lanestyle-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lanestyle"
+version = "0.1.0"
+description = "Lane-level road maps on roadstyle: every lane drawn at its real width, with lane lines, turns and a click-to-see-connectivity view, from a lane table or a duckOSM GMNS database"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Kaveh" }]
+keywords = ["lanes", "lane-level map", "GMNS", "OpenStreetMap", "roadstyle", "duckOSM", "MapLibre", "traffic"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Scientific/Engineering :: GIS",
+  "Topic :: Scientific/Engineering :: Visualization",
+]
+dependencies = ["roadstyle>=0.11", "geopandas", "shapely>=2", "duckdb", "pandas"]
+
+[project.optional-dependencies]
+dev = ["pytest"]
+
+[project.urls]
+Homepage = "https://github.com/Khoshkhah/lanestyle"
+Repository = "https://github.com/Khoshkhah/lanestyle"
+Issues = "https://github.com/Khoshkhah/lanestyle/issues"
+roadstyle = "https://github.com/Khoshkhah/roadstyle"
+duckOSM = "https://github.com/Khoshkhah/duckOSM"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+lanestyle = ["data/*.json"]

lanestyle-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lanestyle-0.1.0/src/lanestyle/__init__.py

@@ -0,0 +1,7 @@
+"""lanestyle — lane-level maps on roadstyle: a lane table (from_gmns reads one from a duckOSM GMNS db)
+drawn one line per lane, at its width in metres."""
+from lanestyle.gmns import boundary_from_geojson, from_gmns, read_boundary
+from lanestyle.render import lane_settings, render_lanes, write_serve
+
+__version__ = "0.1.0"
+__all__ = ["from_gmns", "read_boundary", "boundary_from_geojson", "render_lanes", "lane_settings", "write_serve"]

lanestyle-0.1.0/src/lanestyle/data/lanestyle.json

@@ -0,0 +1,23 @@
+{
+  "lanes": {
+    "colors": {
+      "bus": "#9db8d9",
+      "bike": "#3f8fc9",
+      "clicked": "#e0453a",
+      "turns_into": "#149a86",
+      "uturn": "#8e44ad"
+    },
+    "lines": {
+      "divider": {"color": "#e8e8e8", "width_m": 0.15, "dash_m": [3, 9]},
+      "centre": {"color": "#e8e8e8", "width_m": 0.15, "dash_m": null},
+      "edge": {"color": "#6b6b6b", "width_m": 0.10, "dash_m": null}
+    },
+    "junction_trim_m": 1,
+    "fillet_m": 0,
+    "line_min_device_px": 1.5,
+    "type_label_zoom": 18,
+    "default_width_m": 3.25,
+    "casing_m": 0,
+    "width_m_zoom": 16
+  }
+}

lanestyle-0.1.0/src/lanestyle/gmns.py

@@ -0,0 +1,132 @@
+"""The GMNS reader: a duckOSM GMNS database -> the lane table and turns render_lanes draws."""
+
+
+def _cols(con, schema, table, db=None):
+    q = "SELECT column_name FROM duckdb_columns() WHERE schema_name = ? AND table_name = ?"
+    args = [schema, table]
+    if db:
+        q, args = q + " AND database_name = ?", args + [db]
+    return {c for (c,) in con.execute(q, args).fetchall()}
+
+
+def from_gmns(gmns_db, mode="driving", source_db=None):
+    """Read ``gmns_<mode>.lane`` / ``.link`` / ``.movement`` into ``(lanes, turns)``.
+
+    ``lanes``: a GeoDataFrame, one row per lane (EPSG:4326, each line in the direction of travel)
+    with ``lane_id``, ``highway`` (the link's ``facility_type``), ``width_m`` (``lane.width``; null
+    where untagged, render_lanes fills the default), ``use``, ``name`` (lane 1 only: one label per
+    road), ``link_id``, ``lane_num``, ``turn``, ``from_node_id`` / ``to_node_id`` and
+    ``reverse_link_id`` (the same road the other way: same nodes swapped and the same geometry, so
+    the two halves of a one-way loop are not a pair; null on a one-way road),
+    for the lane lines, ``lanes`` (the link's lane count) and, from ``source_db``, ``bridge`` /
+    ``tunnel`` / ``layer`` and the OSM way ``osm_id``.
+
+    Levels come from the GMNS ``link`` if it has those columns, else from ``source_db`` (the
+    duckOSM database the GMNS file was made from: ``link_id`` = ``<mode>.edges.edge_id``), else
+    every lane is at ground level (no level columns).
+
+    With duckOSM's ``lane_connector`` table, each lane-to-lane connector is a row too
+    (``connector`` True, ``from_lane`` / ``to_lane``; its level and road class from the lane it leaves).
+
+    ``turns``: a DataFrame ``from_lane``, ``to_lane``, ``type`` (the movement type; ``uturn`` is
+    drawn in its own colour), from ``movement``: each lane of the inbound link in
+    ``start_ib_lane``..``end_ib_lane`` into the outbound lane at the same place in
+    ``start_ob_lane``..``end_ob_lane`` (equal-length ranges paired in order, as osm2gmns and duckOSM
+    write them; NULL = every lane). Empty without a movement table."""
+    import uuid
+
+    import duckdb
+    import geopandas as gpd
+    import pandas as pd
+
+    g = f"gmns_{mode}"
+    con = duckdb.connect(str(gmns_db), read_only=True)
+    try:
+        con.execute("INSTALL spatial; LOAD spatial;")
+        if not _cols(con, g, "lane"):
+            raise ValueError(f"no '{g}.lane' in {gmns_db}: build a GMNS db first (duckOSM `duckosm gmns`)")
+        link_cols = _cols(con, g, "link")
+        same = " AND ST_Equals(r.geom, k.geom)" if "geom" in link_cols else ""
+        nlanes = "k.lanes, " if "lanes" in link_cols else ""
+        lvl, src = "", f"lanestyle_src_{uuid.uuid4().hex[:8]}"   # one db instance per file per process:
+        # a caller's own connection to gmns_db may already hold an attachment, so never reuse a name
+        if {"bridge", "tunnel", "layer"} <= link_cols:
+            lvl = ", k.bridge, k.tunnel, k.layer"
+        elif source_db:
+            con.execute(f"ATTACH '{str(source_db).replace(chr(39), chr(39) * 2)}' AS {src} (READ_ONLY)")
+            src_cols = _cols(con, mode, "edges", db=src)
+            if not {"edge_id", "bridge", "tunnel", "layer"} <= src_cols:
+                raise ValueError(f"no {mode}.edges with bridge / tunnel / layer in {source_db}")
+            lvl = ", e.bridge, e.tunnel, e.layer" + (", e.osm_id" if "osm_id" in src_cols else "")
+        join = f"LEFT JOIN {src}.{mode}.edges e ON e.edge_id = l.link_id" if lvl.startswith(", e.") else ""
+        df = con.execute(
+            f"SELECT l.lane_id::VARCHAR AS lane_id, k.facility_type AS highway, l.width AS width_m, "
+            f"  COALESCE(l.allowed_uses, 'auto') AS use, "
+            f"  CASE WHEN l.lane_num = 1 THEN k.name END AS name, "
+            f"  l.link_id, l.lane_num, {nlanes}l.turn, k.from_node_id, k.to_node_id, "
+            f"  (SELECT min(r.link_id) FROM {g}.link r WHERE r.from_node_id = k.to_node_id "
+            f"     AND r.to_node_id = k.from_node_id AND r.link_id <> k.link_id{same}) AS reverse_link_id"
+            f"  {lvl}, ST_AsWKB(l.geom) AS geom "
+            f"FROM {g}.lane l JOIN {g}.link k ON k.link_id = l.link_id {join} "
+            f"WHERE l.geom IS NOT NULL ORDER BY l.link_id, l.lane_num").df()
+        conn = None                    # duckOSM's lane connectors (docs/design/gmns_lane_connectors.md)
+        if _cols(con, g, "lane_connector"):
+            conn = con.execute(f"SELECT connector_id::VARCHAR AS lane_id, from_lane_id::VARCHAR AS from_lane, "
+                               f"to_lane_id::VARCHAR AS to_lane, width AS width_m, ST_AsWKB(geom) AS geom "
+                               f"FROM {g}.lane_connector WHERE geom IS NOT NULL").df()
+        turns = pd.DataFrame({"from_lane": [], "to_lane": [], "type": []}, dtype=object)
+        if _cols(con, g, "movement"):
+            turns = con.execute(
+                f"SELECT DISTINCT il.lane_id::VARCHAR AS from_lane, ol.lane_id::VARCHAR AS to_lane, m.type "
+                f"FROM {g}.movement m "
+                f"JOIN {g}.lane il ON il.link_id = m.ib_link_id AND (m.start_ib_lane IS NULL OR "
+                f"  il.lane_num BETWEEN m.start_ib_lane AND COALESCE(m.end_ib_lane, m.start_ib_lane)) "
+                f"JOIN {g}.lane ol ON ol.link_id = m.ob_link_id AND (m.start_ob_lane IS NULL OR "
+                f"  m.start_ib_lane IS NULL OR ol.lane_num = m.start_ob_lane + il.lane_num - m.start_ib_lane) "
+                f"ORDER BY 1, 2").df()
+    finally:
+        if lvl.startswith(", e."):
+            con.execute(f"DETACH {src}")
+        con.close()
+    for c in [c for c in ("link_id", "reverse_link_id", "from_node_id", "to_node_id", "osm_id") if c in df]:
+        df[c] = df[c].astype("Int64")                       # BIGINT hash ids: never float64
+    df["connector"] = False
+    if conn is not None and len(conn):           # a connector looks like the lane it leaves
+        lane_cols = [c for c in df.columns if c not in ("lane_id", "width_m", "name", "lane_num", "turn", "geom",
+                                                         "connector")]
+        conn = conn.merge(df[["lane_id"] + lane_cols].rename(columns={"lane_id": "from_lane"}), on="from_lane", how="left")
+        conn["connector"] = True
+        df = pd.concat([df, conn], ignore_index=True)
+    for c in [c for c in ("link_id", "reverse_link_id", "from_node_id", "to_node_id", "osm_id") if c in df]:
+        df[c] = df[c].astype("Int64")
+    geom = gpd.GeoSeries.from_wkb(df.pop("geom").map(bytes), crs=4326)
+    return gpd.GeoDataFrame(df, geometry=geom, crs=4326), turns
+
+
+def read_boundary(db):
+    """The area's boundary from a duckOSM database (``main.boundary``, written when the area was built
+    with one) as a shapely geometry, or None. Pass it on: ``render_lanes(..., boundary=geom)``."""
+    import duckdb
+    from shapely import wkb
+
+    con = duckdb.connect(str(db), read_only=True)
+    try:
+        con.execute("INSTALL spatial; LOAD spatial;")
+        if "geom" not in _cols(con, "main", "boundary"):
+            return None
+        row = con.execute("SELECT ST_AsWKB(ST_Union_Agg(geom)) FROM main.boundary").fetchone()
+    finally:
+        con.close()
+    return wkb.loads(bytes(row[0])) if row and row[0] is not None else None
+
+
+def boundary_from_geojson(path):
+    """A GeoJSON file's geometries as one shapely geometry (plain json + shapely, no GDAL)."""
+    import json
+
+    import shapely
+    from shapely.geometry import shape
+
+    gj = json.loads(open(path, encoding="utf-8").read())
+    feats = gj.get("features", [gj] if gj.get("type") == "Feature" else [{"geometry": gj}])
+    return shapely.union_all([shape(f["geometry"]) for f in feats if f.get("geometry")])

lanestyle-0.1.0/src/lanestyle/junctions.py

@@ -0,0 +1,50 @@
+"""Fillets: the paved gaps between lane surfaces. Where a lane joins a road, or two carriageways
+start to diverge, a sliver between the surfaces shows the background. A real road paves it. The
+whole lane surface is closed (grown by ``fillet_m``, shrunk back) and what the closing adds is drawn
+under the lanes, in the colour of the nearest lane."""
+import math
+
+from lanestyle.lines import _band
+
+_CLASS_ORDER = ["motorway", "trunk", "primary", "secondary", "tertiary", "unclassified", "residential",
+                "living_street", "service"]
+
+
+def _rank(cls):
+    c = str(cls or "").replace("_link", "")
+    return _CLASS_ORDER.index(c) if c in _CLASS_ORDER else len(_CLASS_ORDER)
+
+
+def junction_fillets(lanes, s):
+    """GeoJSON polygons (``cls``: the road class whose colour to use, ``b``: the band) of the gaps
+    narrower than ``2 × fillet_m`` anywhere between lane surfaces (lanes and connectors): the whole
+    surface is closed (grown by ``fillet_m``, shrunk back) and what the closing adds is drawn under
+    the lanes, in the colour and band of the nearest lane. Corners at junctions, the slivers between
+    two carriageways that start to diverge, the notches between adjacent lanes' round ends. Real
+    medians wider than ``2 × fillet_m`` stay open. None when off."""
+    import shapely
+
+    r_m = float(s.get("fillet_m") or 0)
+    if not r_m or not len(lanes):
+        return None
+    g = lanes.to_crs(lanes.estimate_utm_crs())
+    surf = g.geometry.buffer(g["width_m"] / 2, cap_style="round")
+    u = shapely.union_all(surf.to_numpy())
+    add = shapely.make_valid(u.buffer(r_m).buffer(-r_m).difference(u)).simplify(0.05)
+    parts = [q for p in getattr(add, "geoms", [add]) for q in getattr(shapely.make_valid(p), "geoms", [shapely.make_valid(p)])
+             if q.geom_type == "Polygon" and q.area > 0.3 and not q.buffer(-0.12).is_empty and q.is_valid]
+    if not parts:
+        return None
+    tree = shapely.STRtree(g.geometry.to_numpy())
+    cls = list(g["highway"]) if "highway" in g else [None] * len(g)
+    band = [_band(r) for r in g.itertuples(index=False)]
+    import geopandas as gpd
+
+    geo = gpd.GeoSeries(parts, crs=g.crs).to_crs(4326)
+    rnd = lambda ring: [[round(x, 7), round(y, 7)] for x, y in ring]  # noqa: E731
+    feats = []
+    for part, gm in zip(parts, geo, strict=True):
+        k = int(tree.nearest(part.representative_point()))
+        feats.append({"type": "Feature", "properties": {"cls": cls[k], "b": band[k]},
+                      "geometry": {"type": "Polygon", "coordinates": [rnd(gm.exterior.coords)] + [rnd(i.coords) for i in gm.interiors]}})
+    return {"type": "FeatureCollection", "features": feats}