lanestyle 0.1.0__py3-none-any.whl

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/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/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/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}

lanestyle/lines.py

@@ -0,0 +1,268 @@
+"""Lane lines (docs/design/lanestyle_on_roadstyle.md, 2b): dividers, centre lines and edge lines,
+cut from the lanes' own geometry, as GeoJSON for the page's line layers."""
+import math
+
+_TRUTHY_NOT = (None, "", "no", "false", "0", 0, False)
+
+
+def _truthy(v):
+    return v not in _TRUTHY_NOT and not (isinstance(v, float) and math.isnan(v))
+
+
+def _band(r):
+    """roadstyle's draw band for a lane (render_web._mark_lvl): the OSM ``layer`` tag, else 1 for a
+    bridge, -1 for a tunnel; the look (tunnel / bridge) from the tags."""
+    try:
+        ly = int(float(getattr(r, "layer", None)))
+    except (TypeError, ValueError):
+        ly = 0
+    br, tu = _truthy(getattr(r, "bridge", None)), _truthy(getattr(r, "tunnel", None))
+    lvl = ly or (1 if br else -1 if tu else 0)
+    if lvl < 0:
+        return "tunnel" if tu else "low"
+    if lvl > 0:
+        return "bridge" if br else "high"
+    return "ground"
+
+
+def _coords(g):
+    r = lambda cs: [[round(x, 7), round(y, 7)] for x, y in cs]
+    if g.geom_type == "LineString":
+        return {"type": "LineString", "coordinates": r(g.coords)}
+    return {"type": "MultiLineString", "coordinates": [r(p.coords) for p in g.geoms]}
+
+
+def _paired(g):
+    """{link_id: partner link_id} for one-way links whose lane 1's left edge lies on another one-way
+    link's lane 1 left edge, running the other way, for at least half its length: a road mapped as
+    two one-way ways (duckOSM places them side by side, docs/design/gmns_paired_carriageways.md).
+    Their shared edge is the centre line, not two edge lines."""
+    import pandas as pd
+    import shapely
+
+    rows = [r for r in g.itertuples(index=False)
+            if r.lane_num == 1 and pd.isna(getattr(r, "reverse_link_id", None))]
+    left = [r.geometry.offset_curve(r.width_m / 2, join_style="mitre", mitre_limit=2.0) for r in rows]
+    keep = [k for k, a in enumerate(left) if a.geom_type == "LineString" and not a.is_empty]
+    rows, left = [rows[k] for k in keep], [left[k] for k in keep]
+    if not rows:
+        return {}
+    tree = shapely.STRtree(left)
+    out = {}
+    for i, a in enumerate(left):
+        if rows[i].link_id in out:
+            continue
+        near = a.buffer(0.6)
+        for j in tree.query(near):
+            b = left[j]
+            if rows[j].link_id in (rows[i].link_id, *out):
+                continue
+            (ax, ay), (bx, by) = _dir(a), _dir(b)
+            if ax * bx + ay * by > -0.866:                       # not running the other way
+                continue
+            if b.intersection(near).length >= 0.5 * min(a.length, b.length):
+                out[rows[i].link_id], out[rows[j].link_id] = rows[j].link_id, rows[i].link_id
+                break
+    return out
+
+
+def _dir(line):
+    """The line's overall direction (start to end), a unit vector."""
+    (x0, y0), (x1, y1) = line.coords[0], line.coords[-1]
+    n = math.hypot(x1 - x0, y1 - y0) or 1.0
+    return (x1 - x0) / n, (y1 - y0) / n
+
+
+def _start_dir(line):
+    """The line's start direction (its first segment), a unit vector."""
+    (x0, y0), (x1, y1) = line.coords[0], line.coords[1]
+    n = math.hypot(x1 - x0, y1 - y0) or 1.0
+    return (x1 - x0) / n, (y1 - y0) / n
+
+
+def _end_dir(line):
+    """The line's end direction (its last segment), a unit vector."""
+    (x0, y0), (x1, y1) = line.coords[-2], line.coords[-1]
+    n = math.hypot(x1 - x0, y1 - y0) or 1.0
+    return (x1 - x0) / n, (y1 - y0) / n
+
+
+def lane_lines(lanes, s):
+    """The lines between and beside lanes as a GeoJSON FeatureCollection; properties ``t`` (type:
+    ``divider`` / ``centre`` / ``edge``), ``b`` (roadstyle band) and ``k`` (the line's width in
+    metres over cos(latitude): × 512·2^z / C is its width in pixels). None when lines are off or
+    the table has no ``link_id`` / ``lane_num``.
+
+    In a link, lane 1 is the leftmost lane in the direction of travel and the lane numbers grow to
+    the right (duckOSM, right-hand traffic): lane k's right edge is the divider to lane k+1, the
+    last lane's the road's edge, lane 1's left edge the centre line (two-way: a ``reverse_link_id``;
+    or a one-way link paired with the opposite one beside it, ``_paired``; drawn once, by the smaller
+    link id) or the edge (one-way). At each end node a line stops where it
+    enters the surface of the other links there (every link at that node but its own and its
+    reverse): at a junction (3 or more neighbours) ``junction_trim_m`` short of it, elsewhere right
+    at it, so the inner edges of a sharp bend meet instead of crossing."""
+    # ponytail: right-hand traffic only (every area so far); left-hand needs duckOSM's lane order there
+    from collections import defaultdict
+
+    import pandas as pd
+    import shapely
+
+    styles = s.get("lines") or {}
+    if not any(styles.values()) or not {"link_id", "lane_num"} <= set(lanes.columns):
+        return None
+    if "connector" in lanes:                     # connectors carry no lane lines
+        lanes = lanes[~lanes["connector"].fillna(False).astype(bool)]
+    g = lanes.to_crs(lanes.estimate_utm_crs())
+    lat = lanes.geometry.representative_point().y.to_numpy()
+    last = g.groupby("link_id")["lane_num"].transform("max").to_numpy()
+    trim = float(s.get("junction_trim_m") or 0)
+    partner = _paired(g)
+    at, surface, cuts = defaultdict(set), {}, {}      # node -> its links; link -> its lanes' surface
+    if {"from_node_id", "to_node_id"} <= set(g.columns):
+        nb = defaultdict(set)
+        for lk, a, b in set(zip(g["link_id"], g["from_node_id"], g["to_node_id"])):
+            nb[a].add(b)
+            nb[b].add(a)
+            at[a].add(lk)
+            at[b].add(lk)
+        junction = {n for n in at if len(nb[n]) >= 3}
+        polys = g.geometry.buffer(g["width_m"] / 2, cap_style="flat")
+        surface = {lk: shapely.union_all(p.to_numpy()) for lk, p in polys.groupby(g["link_id"].to_numpy())}
+
+    # a lane that goes on into another link's lane (lane k's end on lane k's start within 0.3 m,
+    # heading on within 45 degrees, the same width: duckOSM places a road's pieces as one run) is
+    # the same road. Such lanes form a chain: its lines are offset once from the chain's merged
+    # geometry and each piece takes its share, so the joints have no ticks or kinks; and the chain's
+    # links never cut each other's lines. The heading matters: a one-lane one-way road has its lane
+    # on its own line, so at a T-junction the side road's lane starts exactly where the road's ends.
+    from collections import Counter
+
+    from shapely.geometry import LinearRing, LineString, Point, Polygon
+    from shapely.ops import substring
+
+    rows = list(g.itertuples(index=False))
+    nxt, goes_on = {}, defaultdict(set)
+    if {"from_node_id", "to_node_id"} <= set(g.columns):
+        starts = [(r.link_id, r.lane_num, Point(r.geometry.coords[0]), _start_dir(r.geometry), r.width_m) for r in rows]
+        tree = shapely.STRtree([p for _, _, p, _, _ in starts])
+        cand = {}
+        for i, r in enumerate(rows):
+            end, (ex, ey) = Point(r.geometry.coords[-1]), _end_dir(r.geometry)
+            c = [j for j in tree.query(end.buffer(0.3))
+                 if starts[j][0] != r.link_id and starts[j][1] == r.lane_num and starts[j][2].distance(end) <= 0.3
+                 and ex * starts[j][3][0] + ey * starts[j][3][1] > 0.707 and abs(starts[j][4] - r.width_m) < 0.01]
+            if len(c) == 1:
+                cand[i] = c[0]
+        taken = Counter(cand.values())
+        nxt = {i: j for i, j in cand.items() if taken[j] == 1}
+        for i, j in nxt.items():
+            goes_on[rows[i].link_id].add(rows[j].link_id)
+            goes_on[rows[j].link_id].add(rows[i].link_id)
+    prv = {j: i for i, j in nxt.items()}
+    chains, chain_of = [], {}
+    for start in [i for i in range(len(rows)) if i not in prv] + list(range(len(rows))):
+        if start in chain_of:
+            continue
+        ch, x = [], start
+        while x is not None and x not in chain_of:
+            chain_of[x] = len(chains)
+            ch.append(x)
+            x = nxt.get(x)
+        chains.append(ch)
+    closed = {ci for ci, ch in enumerate(chains) if len(ch) > 1 and nxt.get(ch[-1]) == ch[0]}
+    offset_cache = {}
+
+    def chain_line(ci, off):
+        """The chain's merged lanes offset once: (line, is_ring), or None when the geometry won't do."""
+        if (ci, off) in offset_cache:
+            return offset_cache[ci, off]
+        coords = list(rows[chains[ci][0]].geometry.coords)
+        for i in chains[ci][1:]:
+            c = list(rows[i].geometry.coords)
+            coords += c[1:] if Point(c[0]).distance(Point(coords[-1])) < 0.01 else c
+        res = None
+        if ci in closed:
+            if Point(coords[0]).distance(Point(coords[-1])) >= 0.01:
+                coords.append(coords[0])
+            poly = Polygon(coords)
+            if poly.is_valid and poly.area >= 1.0:
+                ccw = LinearRing(coords).is_ccw
+                buf = poly.buffer(-abs(off) if (off > 0) == ccw else abs(off))     # left (+) is inside a ccw ring
+                if not buf.is_empty and buf.geom_type == "Polygon":
+                    bd = list(buf.exterior.coords)
+                    res = (LineString(bd if LinearRing(bd).is_ccw == ccw else bd[::-1]), True)
+        else:
+            line = LineString(coords).offset_curve(off, join_style="mitre", mitre_limit=2.0)
+            if line.geom_type == "LineString" and not line.is_empty:
+                res = (line, False)
+        offset_cache[ci, off] = res
+        return res
+
+    def piece_line(i, off):
+        """Lane i's line at offset ``off``: its share of the chain's one offset line, else its own."""
+        gm = rows[i].geometry
+        ci = chain_of[i]
+        if len(chains[ci]) > 1 and chain_line(ci, off):
+            line, ring = chain_line(ci, off)
+            s0, s1 = line.project(Point(gm.coords[0])), line.project(Point(gm.coords[-1]))
+            if ring and s1 <= s0:
+                seg = LineString(list(substring(line, s0, line.length).coords) + list(substring(line, 0, s1).coords)[1:])
+            else:
+                seg = substring(line, s0, s1)
+            if seg.geom_type == "LineString" and seg.length >= 0.1:
+                return seg.simplify(0.05)
+        return gm.offset_curve(off, join_style="mitre", mitre_limit=2.0).simplify(0.05)
+
+    def cut(node, link, mates):
+        """The other links' surface at a node (grown by the trim at a junction): where lines stop.
+        ``mates``: the link's reverse and paired carriageway, whose surface it shares an edge with,
+        and the links its lanes go on into (one road)."""
+        if node not in at:
+            return None
+        mates = set(mates) | goes_on.get(link, set())
+        if (node, link) not in cuts:
+            other = [surface[k] for k in at[node] if k != link and k not in mates]
+            u = shapely.union_all(other) if other else None
+            cuts[node, link] = u.buffer(trim) if u is not None and trim and node in junction else u
+        return cuts[node, link]
+    out = []
+    for i, r in enumerate(rows):
+        half = r.width_m / 2
+        rev = getattr(r, "reverse_link_id", None)
+        todo = []
+        mate = partner.get(r.link_id)
+        if r.lane_num == 1:
+            if not (rev is None or pd.isna(rev)):
+                if r.link_id < rev:
+                    todo.append(("centre", half))
+            elif mate is not None:                           # one side of a road mapped as 2 ways
+                if r.link_id < mate:
+                    todo.append(("centre", half))
+            else:
+                todo.append(("edge", half))
+        todo.append(("edge" if r.lane_num == last[i] else "divider", -half))
+        mates = {m for m in (None if rev is None or pd.isna(rev) else rev, mate) if m is not None}
+        stops = [c for c in (cut(getattr(r, "from_node_id", None), r.link_id, mates),
+                             cut(getattr(r, "to_node_id", None), r.link_id, mates)) if c is not None]
+        band, sec = _band(r), 1 / math.cos(math.radians(lat[i]))
+        for t, off in todo:
+            st = styles.get(t)
+            if not st:
+                continue
+            line = piece_line(i, off)
+            for c in stops:
+                line = line.difference(c)
+            line = shapely.line_merge(line) if line.geom_type == "MultiLineString" else line
+            parts = [p for p in getattr(line, "geoms", [line]) if p.length >= 0.5]   # no crumbs
+            if not parts:
+                continue
+            line = parts[0] if len(parts) == 1 else shapely.MultiLineString(parts)
+            out.append((t, band, round(st["width_m"] * sec, 4), line))
+    if not out:
+        return None
+    import geopandas as gpd
+
+    geo = gpd.GeoSeries([o[3] for o in out], crs=g.crs).to_crs(4326)
+    return {"type": "FeatureCollection", "features": [
+        {"type": "Feature", "properties": {"t": t, "b": b, "k": k}, "geometry": _coords(gm)}
+        for (t, b, k, _), gm in zip(out, geo)]}

lanestyle/render.py

@@ -0,0 +1,403 @@
+"""The engine: a lane table drawn with roadstyle, one line per lane at its width in metres.
+
+    import lanestyle as ls
+    lanes, turns = ls.from_gmns("monaco_gmns.duckdb", source_db="monaco.duckdb")
+    ls.render_lanes(lanes, turns=turns).save("lanes.html")
+
+Design: docs/design/lanestyle_on_roadstyle.md.
+"""
+import json
+from pathlib import Path
+
+from lanestyle.junctions import junction_fillets
+from lanestyle.lines import lane_lines
+
+_POPUP = ["name", "lane_type", "connects", "highway", "lane_id", "lane_num", "lanes", "use", "turn", "width_m", "tunnel", "bridge",
+          "layer", "turns_in", "turns_out", "from_lane", "to_lane", "link_id", "reverse_link_id", "osm_id", "from_node_id",
+          "to_node_id"]                       # the ones present and not null show
+_MARKED = ("bus", "bike")          # uses painted over the palette; any other use keeps the road colour
+
+# click a lane: it turns `clicked`, the lanes its turns lead into `turns_into`, U-turns `uturn`.
+# roadstyle feature ids are indexes into its source, so lane_id -> id is built on the first click.
+_CLICK_JS = """<script>
+(function(){
+  const T = __TURNS__, C = __COLORS__;
+  let idx = null;
+  const ids = ls => (ls || []).map(l => idx[l]).filter(i => i !== undefined);
+  document.addEventListener("rs:select", e => {
+    const d = e.detail || {};
+    if (d.overlay || d.id == null) return;
+    if (!idx) { idx = {}; const all = rsQuery(() => true), rows = rsGetProps(all);
+                all.forEach((id, k) => { idx[rows[k].lane_id] = id; }); }
+    const t = T[(d.properties || {}).lane_id] || [];
+    rsColor([[[d.id], C.clicked], [ids(t[0]), C.turns_into], [ids(t[1]), C.uturn]]);
+  });
+  document.addEventListener("rs:deselect", () => rsColor(null));
+})();
+</script>
+"""
+
+
+# the lane lines: one MapLibre line layer per band and type, right after that band's fill, so a
+# bridge covers the lines of the street under it; widths in metres (k = width_m / cos(lat)) from
+# width_m_zoom, dashes in multiples of the line width (dash_m / width_m), exact at every zoom
+_LINES_JS = """<script>
+(function(){
+  const D = __LINES__, S = __STYLES__, Z = __ZOOM__;
+  // never thinner than one physical pixel of this screen (a sub-pixel line vanishes in some browsers
+  // and at browser zooms under 100 %), true to scale above that; faded in over two zoom levels
+  const MIN = __MIN_DEVICE_PX__ / (window.devicePixelRatio || 1);     // compact columns (_compact), rebuilt here
+  const L = {type: "FeatureCollection", features: D.c.map((c, i) => ({type: "Feature",
+    properties: {t: D.types[D.t[i]], b: D.bands[D.b[i]], k: D.k[i]},
+    geometry: {type: Array.isArray(c[0][0]) ? "MultiLineString" : "LineString", coordinates: c}}))};
+  // after the band's last fill layer: roadstyle (main, 2026-09-30) draws tunnel stretches at street
+  // level (roads-tunnelgr-*, after the under-road pieces); older versions have only roads-tunnel-fill
+  const AFTER = {tunnel: ["roads-tunnelgr-fill", "roads-tunnel-under-fill", "roads-tunnel-fill"],
+                 low: ["roads-low-fill"], ground: ["roads-fill"], high: ["roads-high-fill"],
+                 bridge: ["roads-bridge-fill"]};
+  const px = z => 512 * Math.pow(2, z) / 40075016.686;
+  function add(){
+    if (map.getSource("lane-lines")) return;
+    map.addSource("lane-lines", {type: "geojson", data: L});
+    const ids = map.getStyle().layers.map(l => l.id);
+    for (const b in AFTER) {
+      const after = AFTER[b].find(id => ids.includes(id));
+      if (!after) continue;
+      const i = ids.indexOf(after);
+      for (const t in S) {
+        const s = S[t];
+        if (!s) continue;
+        const w = ["interpolate", ["exponential", 2], ["zoom"]];
+        for (let z = Z; z <= 22; z++) w.push(z, ["max", ["*", ["get", "k"], px(z)], MIN]);
+        const paint = {"line-color": s.color, "line-width": w,
+                       "line-opacity": ["interpolate", ["linear"], ["zoom"], Z, 0.35, Z + 2, 1]};
+        if (s.dash_m) paint["line-dasharray"] = s.dash_m.map(d => d / s.width_m);
+        map.addLayer({id: "lane-lines-" + b + "-" + t, type: "line", source: "lane-lines", minzoom: Z,
+                      filter: ["all", ["==", ["get", "t"], t], ["==", ["get", "b"], b]],
+                      layout: {"line-cap": "butt", "line-join": "round"}, paint: paint}, ids[i + 1]);
+      }
+    }
+  }
+  if (map.isStyleLoaded()) add(); else map.once("load", add);
+})();
+</script>
+"""
+
+
+def _compact(fc):
+    """The lines as columns, not GeoJSON features: a city's ~35k lines are half wrapping otherwise."""
+    fs = fc["features"]
+    types = sorted({f["properties"]["t"] for f in fs})
+    bands = sorted({f["properties"]["b"] for f in fs})
+    return {"types": types, "bands": bands,
+            "t": [types.index(f["properties"]["t"]) for f in fs],
+            "b": [bands.index(f["properties"]["b"]) for f in fs],
+            "k": [f["properties"]["k"] for f in fs], "c": [f["geometry"]["coordinates"] for f in fs]}
+
+
+# roadstyle's tunnel look (a 45 % see-through fill over a dashed casing, light dashes on the fill) is
+# made for road-width lines; at lane width the dashes become blocks, every connector dashes from its
+# own start (fans where they overlap), and see-through lanes show every overlap. Lane maps draw
+# tunnels at 85 %, a plain casing, no fill dashes: a tunnel still reads lighter, overlaps hardly show
+_ROADSTYLE = {"config": {"tunnel_gap_shade": 0, "tunnel_dash_shade": 0, "tunnel_opacity_scale": 0.85,
+                         "tunnel_fill_dash": []}}
+
+
+def _break_twins(g):
+    """roadstyle pairs two lines with swapped end points (to 6 decimals) as a two-way road's two
+    directions and shifts them apart. Lanes are never such a pair (each has its own geometry), but the
+    two halves of a one-way loop are: nudge one end of the later one by 2e-6 degrees (~0.2 m)."""
+    # ponytail: geometry nudge; roadstyle's `twoway_col` (in progress on its main) replaces it
+    from shapely.geometry import LineString
+
+    key = lambda c: (round(c[0], 6), round(c[1], 6))
+    seen, geoms = set(), list(g.geometry)
+    for i, ln in enumerate(geoms):
+        if ln is None or ln.geom_type != "LineString":
+            continue
+        cs = list(ln.coords)
+        a, z = key(cs[0]), key(cs[-1])
+        if (z, a) in seen:
+            cs[-1] = (cs[-1][0] + 2e-6, cs[-1][1] + 2e-6)
+            geoms[i] = LineString(cs)
+            z = key(cs[-1])
+        seen.add((a, z))
+    return g.set_geometry(geoms, crs=g.crs)
+
+
+# a lane's type label: the turns that leave it, in this order, as these words
+_TYPE_ORDER = ["left", "uturn", "thru", "diverge", "merge", "right"]
+_TYPE_WORD = {"left": "left", "uturn": "U-turn", "thru": "thru", "diverge": "fork", "merge": "merge",
+              "right": "right"}
+
+# the type label along each lane (lane_type), from zoom __ZOOM__, in roadstyle's street-name font
+_LABELS_JS = """<script>
+(function(){
+  function add(){
+    if (map.getLayer("lane-type-labels")) return;
+    const font = map.getLayer("roads-labels") ? map.getLayoutProperty("roads-labels", "text-font") : null;
+    map.addLayer({id: "lane-type-labels", type: "symbol", source: "roads", minzoom: __ZOOM__,
+      filter: ["!", ["to-boolean", ["get", "connector"]]],     // lanes only; a connector says it in its popup
+      layout: Object.assign({"symbol-placement": "line", "text-field": ["get", "lane_type"], "text-size": 11,
+                             "symbol-spacing": 220, "text-keep-upright": true}, font ? {"text-font": font} : {}),
+      paint: {"text-color": "#1b1b1b", "text-halo-color": "#ffffff", "text-halo-width": 1.5}});
+  }
+  if (map.isStyleLoaded()) add(); else map.once("load", add);
+})();
+</script>
+"""
+
+
+
+
+# bus / bike lanes are coloured with roadstyle's "colour by" (Road class + Lane use, the latter on),
+# but its dropdown and legend box are hidden: the colours get rows in the Roads filter box instead,
+# under the road classes, before Bridges / Tunnels
+_USE_ROWS_JS = """<style>.co-ctrl,.co-lg{display:none!important}</style>
+<script>
+(function(){
+  const ROWS = __ROWS__;
+  function add(){
+    const body = document.querySelector(".flt-ctrl .flt-body");
+    if (!body) return setTimeout(add, 200);
+    if (body.querySelector(".ls-use")) return;
+    const before = body.querySelector(".flt-grade");
+    ROWS.forEach(([label, color], i) => {
+      const lab = document.createElement("label"); lab.className = "ls-use";
+      if (i === 0) lab.style.cssText = "margin-top:4px;padding-top:4px;border-top:1px solid #ddd";
+      const pad = document.createElement("input"); pad.type = "checkbox"; pad.style.visibility = "hidden";
+      const sw = document.createElement("span"); sw.className = "flt-sw"; sw.style.background = color;
+      lab.appendChild(pad); lab.appendChild(sw); lab.appendChild(document.createTextNode(" " + label));
+      body.insertBefore(lab, before);
+    });
+  }
+  add();
+})();
+</script>
+"""
+
+
+def _lane_types(g, turns):
+    """Each lane's type label: the turns that leave it (``left + thru``, ``U-turn``, ``fork``, ``merge``)
+    or ``end`` where none does; a bus or bike lane says so first (``bus · thru``)."""
+    out = {}
+    types = turns["type"] if "type" in turns else ["turn"] * len(turns)
+    for a, t in zip(turns["from_lane"].astype(str), types):
+        out.setdefault(a, set()).add(t)
+
+    def label(lane, use):
+        ts = out.get(lane, set())
+        words = " + ".join(_TYPE_WORD.get(t, t) for t in _TYPE_ORDER + sorted(ts - set(_TYPE_ORDER)) if t in ts)
+        return (words or "end") if use == "auto" else f"{use} · {words or 'end'}"
+    return [label(lane, use) for lane, use in zip(g["lane_id"], g["use"])]
+
+
+# roadstyle ends its tunnel layers flat (butt caps, for the casing's dash ticks); at lane width two
+# flat ends meeting at an angle leave a wedge of background, so lane maps give them round ends like
+# every other road layer (Kaveh: "use curving for road end points")
+_ROUND_ENDS_JS = """<script>
+(function(){
+  function round(){
+    for (const l of map.getStyle().layers)
+      if (l.type === "line" && l.id.startsWith("roads-tunnel") && map.getLayoutProperty(l.id, "line-cap") === "butt")
+        map.setLayoutProperty(l.id, "line-cap", "round");
+  }
+  if (map.isStyleLoaded()) round(); else map.once("load", round);
+})();
+</script>
+"""
+
+# the junction fillets, a fill layer under each band's lanes, in the node's main road's colour
+# (roadstyle's class colours, read from the page)
+_FILLETS_JS = """<script>
+(function(){
+  const F = __FILLETS__;
+  const BEFORE = {tunnel: ["roads-tunnel-fill"], low: ["roads-low-fill"], ground: ["roads-fill"],
+                  high: ["roads-high-fill"], bridge: ["roads-bridge-fill"]};
+  function add(){
+    if (map.getSource("lane-fillets")) return;
+    map.addSource("lane-fillets", {type: "geojson", data: F});
+    const cols = window.RS_CLASS_COLORS || {};
+    const color = ["match", ["get", "cls"]];
+    for (const k in cols) color.push(k, cols[k]);
+    color.push("#888888");
+    const ids = map.getStyle().layers.map(l => l.id);
+    for (const b in BEFORE) {
+      const before = BEFORE[b].find(id => ids.includes(id));
+      if (!before) continue;
+      map.addLayer({id: "lane-fillets-" + b, type: "fill", source: "lane-fillets",
+                    filter: ["==", ["get", "b"], b],
+                    paint: {"fill-color": Object.keys(cols).length ? color : "#888888",
+                            "fill-opacity": b === "tunnel" ? 0.85 : 1}}, before);
+    }
+  }
+  if (map.isStyleLoaded()) add(); else map.once("load", add);
+})();
+</script>
+"""
+
+
+def _merge(a, b):
+    """``a`` updated by ``b``, nested dicts merged (state only what changes)."""
+    out = dict(a)
+    for k, v in (b or {}).items():
+        out[k] = _merge(out[k], v) if isinstance(v, dict) and isinstance(out.get(k), dict) else v
+    return out
+
+
+def lane_settings(settings=None):
+    """lanestyle's settings: ``data/lanestyle.json``, then a ``lanestyle.json`` in the current folder,
+    then ``settings["lanes"]``, each overriding only what it states (the roadstyle.json way)."""
+    s = json.loads((Path(__file__).parent / "data" / "lanestyle.json").read_text())["lanes"]
+    local = Path("lanestyle.json")
+    if local.is_file():
+        s = _merge(s, json.loads(local.read_text()).get("lanes"))
+    return _merge(s, (settings or {}).get("lanes"))
+
+
+def render_lanes(lanes, turns=None, palette="mono", settings=None, **kwargs):
+    """Draw a lane table (see :func:`lanestyle.from_gmns` for the columns) as one roadstyle map and
+    return roadstyle's ``WebMap`` (``.save(path)``, ``.html``).
+
+    Each lane is one line on its own geometry, exactly ``width_m`` metres wide from
+    ``width_m_zoom`` on (``default_width_m`` where null). Bus and bike lanes are painted over the
+    palette (a "Lane use" colouring; the legend lists only uses present). ``turns`` (``from_lane``,
+    ``to_lane``, optional ``type``) makes a lane clickable: it turns red and the lanes it leads into
+    green, U-turns purple. Lane lines (dividers, centre and edge lines, styled per type under
+    ``lines``) come from ``link_id`` / ``lane_num`` (+ ``reverse_link_id``, node ids; see
+    :func:`lanestyle.lines.lane_lines`). ``settings``: roadstyle settings, plus a ``"lanes"`` key
+    for lanestyle's own (``data/lanestyle.json``). Other keywords go to ``roadstyle.render_edges``."""
+    import roadstyle as rs
+
+    s = lane_settings(settings)
+    g = lanes.copy()
+    g["width_m"] = g["width_m"].fillna(s["default_width_m"]) if "width_m" in g else s["default_width_m"]
+    g["use"] = g["use"].fillna("auto") if "use" in g else "auto"
+    present = {u: s["colors"][u] for u in _MARKED if u in set(g["use"])}
+    opts = {}
+    if present:
+        opts = dict(color_options={"Road class": {}, "Lane use": {"color_by": "use", "colors": present}},
+                    color_active="Lane use")
+    conn = g["connector"].fillna(False).astype(bool) if "connector" in g else None
+    if conn is not None:                                 # arrows on lanes, not on connectors
+        g["oneway"] = ~conn
+    if turns is not None and len(turns):                 # what each lane is for (label + popup)
+        g["lane_type"] = _lane_types(g, turns)
+        if conn is not None and conn.any():              # a connector says what it is, in words
+            kind = dict(zip(zip(turns["from_lane"].astype(str), turns["to_lane"].astype(str)),
+                            turns["type"] if "type" in turns else ["turn"] * len(turns)))
+            road = dict(zip(g["lane_id"], g.get("name", [None] * len(g))))
+            num = dict(zip(g["lane_id"], g.get("lane_num", [None] * len(g))))
+            first = {}                                   # a road's name sits on its lane 1 only
+            for lid, nm in road.items():
+                if isinstance(nm, str):
+                    first[str(lid).rsplit("_", 1)[0]] = nm
+
+            def says(a, b):
+                def lane(x):
+                    n = num.get(x)
+                    nm = first.get(str(x).rsplit("_", 1)[0]) or "(unnamed road)"
+                    return f"lane {int(n)} of {nm}" if n == n and n is not None else str(x)
+                return f"{lane(a)} → {lane(b)}"
+            g.loc[conn, "lane_type"] = ["connector · " + _TYPE_WORD.get(kind.get((a, b)), kind.get((a, b)) or "turn")
+                                         for a, b in zip(g.loc[conn, "from_lane"], g.loc[conn, "to_lane"])]
+            g.loc[conn, "connects"] = [says(a, b) for a, b in zip(g.loc[conn, "from_lane"], g.loc[conn, "to_lane"])]
+    if turns is not None and len(turns):                 # how many lanes lead in / out, for the popup
+        g["turns_in"] = g["lane_id"].map(turns.groupby(turns["to_lane"].astype(str)).size()).fillna(0).astype(int)
+        g["turns_out"] = g["lane_id"].map(turns.groupby(turns["from_lane"].astype(str)).size()).fillna(0).astype(int)
+    lines = lane_lines(g, s)
+    fillets = junction_fillets(g, s)             # connectors included: their corners are the usual gaps
+    m = rs.render_edges(
+        _break_twins(g), palette=palette,
+        width_m_col="width_m", width_m_zoom=s["width_m_zoom"], casing_m=s["casing_m"],
+        road_popup=[c for c in _POPUP if c in g.columns],
+        **{"select_color": s["colors"]["clicked"], **kwargs},   # roadstyle's own selection glow
+        settings=_merge(_ROADSTYLE, {k: v for k, v in (settings or {}).items() if k != "lanes"}),
+        **opts)
+    js = _ROUND_ENDS_JS
+    if fillets:
+        js += _FILLETS_JS.replace("__FILLETS__", json.dumps(fillets, separators=(",", ":")))
+    if present:                                          # bus / bike colours as rows in the Roads box
+        js += _USE_ROWS_JS.replace("__ROWS__", json.dumps([[f"{u} lanes", c] for u, c in present.items()]))
+    if lines:
+        js += (_LINES_JS.replace("__LINES__", json.dumps(_compact(lines), separators=(",", ":")))
+               .replace("__STYLES__", json.dumps(s["lines"])).replace("__ZOOM__", json.dumps(s["width_m_zoom"]))
+               .replace("__MIN_DEVICE_PX__", json.dumps(s.get("line_min_device_px", 1))))
+    if turns is not None and len(turns):
+        via = {}                                         # (from lane, to lane) -> its connector
+        if conn is not None and conn.any():
+            via = dict(zip(zip(g.loc[conn, "from_lane"], g.loc[conn, "to_lane"]), g.loc[conn, "lane_id"]))
+        js += _click_js(turns, s, via)
+        if s.get("type_label_zoom") is not None:
+            js += _LABELS_JS.replace("__ZOOM__", json.dumps(s["type_label_zoom"]))
+    if not js:
+        return m
+    html = m.html
+    i = html.rfind("</body>")
+    return type(m)(html[:i] + js + html[i:])
+
+
+def _click_js(turns, s, via=None):
+    nxt, via = {}, via or {}
+    types = turns["type"] if "type" in turns else [None] * len(turns)
+    for a, b, t in zip(turns["from_lane"].astype(str), turns["to_lane"].astype(str), types):
+        nxt.setdefault(a, [[], []])[t == "uturn"].append(b)
+        if (a, b) in via:                                # and the connector into it
+            nxt[a][t == "uturn"].append(via[a, b])
+    return (_CLICK_JS.replace("__TURNS__", json.dumps(nxt, separators=(",", ":")))
+            .replace("__COLORS__", json.dumps({k: s["colors"][k] for k in ("clicked", "turns_into", "uturn")})))
+
+
+_SERVE_PY = '''#!/usr/bin/env python3
+"""Static server for this lanestyle render.
+   python serve.py [port]   ->  http://localhost:8080/__INDEX__"""
+import sys, http.server, socketserver
+from functools import partial
+from pathlib import Path
+
+
+class Handler(http.server.SimpleHTTPRequestHandler):
+    def do_GET(self):
+        if self.path in ("/", "/index.html") and self.path != "/__INDEX__":   # the root URL opens the map
+            self.send_response(302)
+            self.send_header("Location", "/__INDEX__")
+            self.end_headers()
+            return
+        super().do_GET()
+
+    def end_headers(self):
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Cache-Control", "no-store")   # a rebuilt map shows on a plain reload
+        super().end_headers()
+
+
+socketserver.TCPServer.allow_reuse_address = True
+port = int(sys.argv[1]) if len(sys.argv) > 1 else 8080
+here = str(Path(__file__).resolve().parent)
+for p in range(port, port + 20):                       # 8080 busy? hop to the next free port
+    try:
+        httpd = socketserver.TCPServer(("", p), partial(Handler, directory=here))
+    except OSError:
+        continue
+    if p != port:
+        print(f"port {port} busy -> using {p}")
+    print(f"serving {here}")
+    print(f"  open:    http://localhost:{p}/   (-> __INDEX__)")
+    print(f"  REMOTE:  forward port {p}  (VS Code auto-forwards it in the Ports panel; "
+          f"or `ssh -L {p}:localhost:{p} <host>`), then open the URL above")
+    httpd.serve_forever()
+    break
+else:
+    sys.exit(f"no free port in {port}..{port + 19}")
+'''
+
+
+def write_serve(out_html):
+    """Drop a ``serve.py`` next to ``out_html`` — ``python serve.py [port]`` serves that folder (auto-hops
+    off a busy port) and prints the map URL. Returns the serve.py path."""
+    from pathlib import Path
+
+    out_html = Path(out_html)
+    serve = out_html.parent / "serve.py"
+    serve.write_text(_SERVE_PY.replace("__INDEX__", out_html.name))
+    return serve

lanestyle-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,11 @@
+lanestyle/__init__.py,sha256=tNLxVer3vVM69SdCjXd47fvudNA3YmO-GHOSEvgnlHA,439
+lanestyle/gmns.py,sha256=vY5O184DacfUeejDVvWTZfLIGVa-c3wZeEXrfxRgEaM,7735
+lanestyle/junctions.py,sha256=PyXxzlK2t65yxlegXFS8FpU-6mTTB2y2sZfW8Zvw9ns,2664
+lanestyle/lines.py,sha256=-Sj4TjP-2QhifWy23hXREecod4UO6NaH2deL6OaQnbw,12972
+lanestyle/render.py,sha256=BCpeyJj4JaL86PpMz4Kd2BiCywRa5Ky2jAr_QTqVOSw,20238
+lanestyle/data/lanestyle.json,sha256=r-3vTL-eD1dNilS7u_e7eWx2T9oe_kmIoVcZdPmt0ck,586
+lanestyle-0.1.0.dist-info/licenses/LICENSE,sha256=DUKTbcaVakZEV31GY9Lbh9wLIdmJMCWOpKo8EwtA2Ts,1062
+lanestyle-0.1.0.dist-info/METADATA,sha256=4KtvOrzDlagF-ccK2w5p4FNa-kb0CdnSBENsRoCRG8k,10534
+lanestyle-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+lanestyle-0.1.0.dist-info/top_level.txt,sha256=gVmhr6eJklcEu-yLcO2dop2hgrv3tv8ypHPpQJXqOf8,10
+lanestyle-0.1.0.dist-info/RECORD,,

lanestyle-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lanestyle-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+lanestyle