mapstyle 0.2.0__tar.gz → 0.3.0__tar.gz

{mapstyle-0.2.0/src/mapstyle.egg-info → mapstyle-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapstyle
-Version: 0.2.0
+Version: 0.3.0
 Summary: A whole OpenStreetMap map in one offline HTML page: roads for every travel mode over a full base map, from a duckOSM database
 Author: Kaveh Khoshkhah
 License-Expression: MIT
@@ -18,15 +18,18 @@ Classifier: Topic :: Scientific/Engineering :: Visualization
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: roadstyle>=0.10.0
+Requires-Dist: roadstyle>=0.12.0
 Requires-Dist: duckdb
 Requires-Dist: geopandas
 Requires-Dist: pyyaml
 Requires-Dist: pillow
 Provides-Extra: tiles
 Requires-Dist: roadstyle[tiles]; extra == "tiles"
+Provides-Extra: solver
+Requires-Dist: ortools>=9.10; extra == "solver"
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ortools>=9.10; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: mkdocs<2,>=1.6; extra == "docs"
 Requires-Dist: mkdocs-material<10,>=9.5; extra == "docs"
@@ -83,7 +86,7 @@ import mapstyle as ms
 ms.render_map("monaco.duckdb").save("monaco.html")                    # the whole map
 ms.render_map("monaco.duckdb", mode="walking", paths="komoot")        # paths in front
 ms.render_map("monaco.duckdb", theme="grey")                          # a quiet map for data
-ms.render_map("monaco.duckdb", planner=True).save("planner.html")     # + a route planner
+ms.render_map("monaco.duckdb", planner=True).save("planner.html")     # a route planner demo
 ms.render_map("monaco.duckdb", dashboard=True).save("dashboard.html") # a dashboard
 ```
 
@@ -94,10 +97,12 @@ ms.render_map("monaco.duckdb", dashboard=True).save("dashboard.html") # a dashbo
   for the whole map: `osm` (detailed), `google` (clean), `grey` (quiet, for your data on top).
 - **A full base map from the same database**: the sea, land use with openstreetmap.org's textures,
   water, buildings, railways, parking, transit, traffic lights and crossings. No tile server, no API key.
-- **Roads drawn right at junctions**: two-way roads as two lanes, bridges over, tunnels under only
-  where they really pass under a road, raised walkways, crossings over their street.
-- **A route planner** in the page: drive, walk, cycle or walk + drive, fastest or shortest, with
-  turn-by-turn directions.
+- **Roads drawn right at junctions**: two-way roads as two lanes, bridges and overpasses over, tunnels
+  under, crossings over their street. The drawing order of the roads is solved (an interval per road,
+  `render_map(order=True)`; `pip install mapstyle[solver]` for the exact solution), so a joint of
+  roads at different levels shows no ring.
+- **A route planner demo**: drag a start and an end and see duckOSM's route on the map (routing
+  itself is duckOSM's job).
 - **A dashboard**: filter by mode, road class and layer, colour by mode, inspect what you click.
 - **A JavaScript API**: every page is a [roadstyle](https://github.com/Khoshkhah/roadstyle) page
   (`rsQuery`, `rsFilter`, `rsColor`, …) plus `rsSetModes`, `rsSetKinds` and `rsSetInteraction`;
@@ -109,7 +114,7 @@ ms.render_map("monaco.duckdb", dashboard=True).save("dashboard.html") # a dashbo
     <td><img src="https://raw.githubusercontent.com/Khoshkhah/mapstyle/main/docs/img/roads_walkway.jpg" alt="A raised walkway over a roundabout"><br><sub>A raised walkway over a roundabout</sub></td>
   </tr>
   <tr>
-    <td><img src="https://raw.githubusercontent.com/Khoshkhah/mapstyle/main/docs/img/planner.jpg" alt="The route planner"><br><sub>The route planner</sub></td>
+    <td><img src="https://raw.githubusercontent.com/Khoshkhah/mapstyle/main/docs/img/planner.jpg" alt="The route planner"><br><sub>The route planner demo</sub></td>
     <td><img src="https://raw.githubusercontent.com/Khoshkhah/mapstyle/main/docs/img/dashboard.jpg" alt="The dashboard"><br><sub>The dashboard</sub></td>
   </tr>
 </table>

{mapstyle-0.2.0 → mapstyle-0.3.0}/README.md

@@ -48,7 +48,7 @@ import mapstyle as ms
 ms.render_map("monaco.duckdb").save("monaco.html")                    # the whole map
 ms.render_map("monaco.duckdb", mode="walking", paths="komoot")        # paths in front
 ms.render_map("monaco.duckdb", theme="grey")                          # a quiet map for data
-ms.render_map("monaco.duckdb", planner=True).save("planner.html")     # + a route planner
+ms.render_map("monaco.duckdb", planner=True).save("planner.html")     # a route planner demo
 ms.render_map("monaco.duckdb", dashboard=True).save("dashboard.html") # a dashboard
 ```
 
@@ -59,10 +59,12 @@ ms.render_map("monaco.duckdb", dashboard=True).save("dashboard.html") # a dashbo
   for the whole map: `osm` (detailed), `google` (clean), `grey` (quiet, for your data on top).
 - **A full base map from the same database**: the sea, land use with openstreetmap.org's textures,
   water, buildings, railways, parking, transit, traffic lights and crossings. No tile server, no API key.
-- **Roads drawn right at junctions**: two-way roads as two lanes, bridges over, tunnels under only
-  where they really pass under a road, raised walkways, crossings over their street.
-- **A route planner** in the page: drive, walk, cycle or walk + drive, fastest or shortest, with
-  turn-by-turn directions.
+- **Roads drawn right at junctions**: two-way roads as two lanes, bridges and overpasses over, tunnels
+  under, crossings over their street. The drawing order of the roads is solved (an interval per road,
+  `render_map(order=True)`; `pip install mapstyle[solver]` for the exact solution), so a joint of
+  roads at different levels shows no ring.
+- **A route planner demo**: drag a start and an end and see duckOSM's route on the map (routing
+  itself is duckOSM's job).
 - **A dashboard**: filter by mode, road class and layer, colour by mode, inspect what you click.
 - **A JavaScript API**: every page is a [roadstyle](https://github.com/Khoshkhah/roadstyle) page
   (`rsQuery`, `rsFilter`, `rsColor`, …) plus `rsSetModes`, `rsSetKinds` and `rsSetInteraction`;
@@ -74,7 +76,7 @@ ms.render_map("monaco.duckdb", dashboard=True).save("dashboard.html") # a dashbo
     <td><img src="https://raw.githubusercontent.com/Khoshkhah/mapstyle/main/docs/img/roads_walkway.jpg" alt="A raised walkway over a roundabout"><br><sub>A raised walkway over a roundabout</sub></td>
   </tr>
   <tr>
-    <td><img src="https://raw.githubusercontent.com/Khoshkhah/mapstyle/main/docs/img/planner.jpg" alt="The route planner"><br><sub>The route planner</sub></td>
+    <td><img src="https://raw.githubusercontent.com/Khoshkhah/mapstyle/main/docs/img/planner.jpg" alt="The route planner"><br><sub>The route planner demo</sub></td>
     <td><img src="https://raw.githubusercontent.com/Khoshkhah/mapstyle/main/docs/img/dashboard.jpg" alt="The dashboard"><br><sub>The dashboard</sub></td>
   </tr>
 </table>

{mapstyle-0.2.0 → mapstyle-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mapstyle"
-version = "0.2.0"
+version = "0.3.0"
 description = "A whole OpenStreetMap map in one offline HTML page: roads for every travel mode over a full base map, from a duckOSM database"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -22,7 +22,7 @@ classifiers = [
 ]
 
 dependencies = [
-    "roadstyle>=0.10.0",  # the page (band_col, directed_col, tunnel stretches)
+    "roadstyle>=0.12.0",  # the page (casing_level_col / fill_level_col, band_col, directed_col, cap_col)
     "duckdb",             # reads the duckOSM db
     "geopandas",
     "pyyaml",             # styles/*.yaml
@@ -31,7 +31,8 @@ dependencies = [
 
 [project.optional-dependencies]
 tiles = ["roadstyle[tiles]"]   # --tiles / render_map(tiles=True)
-dev = ["pytest"]
+solver = ["ortools>=9.10"]   # the drawing order of the roads (order=True) is solved exactly; without it a heuristic is used
+dev = ["pytest", "ortools>=9.10"]
 docs = ["mkdocs>=1.6,<2", "mkdocs-material>=9.5,<10", "mkdocs-llmstxt>=0.5,<0.6"]
 
 [project.urls]

{mapstyle-0.2.0 → mapstyle-0.3.0}/src/mapstyle/__init__.py

@@ -2,5 +2,5 @@
 
 from mapstyle.map import MODES, load_layers, load_roads, render_map
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __all__ = ["MODES", "load_layers", "load_roads", "render_map", "__version__"]

mapstyle-0.3.0/src/mapstyle/dashboard.js

@@ -0,0 +1,164 @@
+// mapstyle's dashboard (docs/design/dashboard.md) on roadstyle's report panel: a Modes box, and
+// under each feature layer's box its clickable / tooltip / popup switches and its kinds. UI only,
+// over rsSetModes, rsSetInteraction and rsSetKinds (layers.js). Without the report's panel
+// (#rp-ovs) it falls back to a box in the page's corner.
+(function wait(){
+  if (!(window.rsSetKinds && window.RS_KINDS && rsQuery(() => true).length)) return setTimeout(wait, 200);
+  const esc = (s) => String(s).replace(/[&<>"]/g, (c) => ({"&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;"}[c]));
+  const fmt = (n) => n.toLocaleString();
+  const el = (tag, cls, html) => { const e = document.createElement(tag); if (cls) e.className = cls; if (html) e.innerHTML = html; return e; };
+  const check = (text, on, change, count) => {
+    const lab = el("label", "rp-chk"), cb = el("input");
+    cb.type = "checkbox"; cb.checked = on; cb.onchange = () => change(cb.checked);
+    lab.appendChild(cb); lab.appendChild(document.createTextNode(" " + text));
+    if (count != null) lab.appendChild(el("span", "rp-ct", fmt(count)));
+    return lab;
+  };
+  document.head.appendChild(el("style", null,
+    ".ms-grp{margin:0 0 10px;border:1px solid var(--line,#e5e7eb);border-radius:10px;padding:2px 10px 6px}" +
+    ".ms-grp>summary{display:flex;align-items:center;gap:6px;cursor:pointer;font-size:11px;font-weight:600;" +
+    "letter-spacing:.05em;text-transform:uppercase;color:var(--mut,#6b7280);padding:6px 0}" +
+    ".ms-grp>summary .ms-n{font-weight:400;opacity:.7}.ms-grp>summary .ms-all{margin-left:auto;text-transform:none;letter-spacing:0;font-weight:400}" +
+    ".ms-row{display:flex;flex-wrap:wrap;align-items:center}.ms-row>label{flex:1}.ms-set{flex-basis:100%;margin:0 0 4px 22px;font-size:12px}" +
+    ".ms-gear{border:0;background:none;cursor:pointer;color:var(--mut,#9ca3af);font-size:13px;padding:0 4px;opacity:.7}.ms-gear:hover,.ms-gear.on{opacity:1}" +
+    "#rp-kpis{display:grid!important;grid-template-columns:repeat(3,1fr);gap:6px}#rp-kpis .rp-kpi{padding:6px 8px;min-width:0}#rp-kpis .rp-kv{font-size:17px}" +
+    ".ms-modes{display:flex;flex-wrap:wrap;gap:6px;margin:0 0 8px}.ms-modes .rp-grp{flex-basis:100%;margin:2px 0 0}" +
+    ".ms-modes .rp-chk{display:inline-flex;align-items:center;gap:4px;margin:0;padding:2px 9px;border:1px solid var(--line,#e5e7eb);border-radius:14px}" +
+    ".ms-modes .rp-ct{margin-left:4px}" +
+    "#rp-cls{max-height:260px;overflow-y:auto}#rp-cls .rp-grp{position:sticky;top:0;background:var(--bg,#fff);z-index:1;padding:2px 0}" +
+    ".ms-sw{display:flex;gap:10px;margin:3px 0}.ms-sw label{cursor:pointer}" +
+    ".ms-kinds{max-height:160px;overflow-y:auto}.ms-kinds .rp-chk{font-size:12px}" +
+    ".ms-all{font-size:11px;margin:2px 0}.ms-all a{margin-right:8px;cursor:pointer;color:#555}" +
+    ".ms-float{position:fixed;left:10px;bottom:30px;z-index:5;max-height:60vh;overflow-y:auto;" +
+    "background:#fff;padding:8px 10px;border-radius:6px;box-shadow:0 1px 4px rgba(0,0,0,.3);font:13px system-ui}"));
+  // ---- a road cut into pieces is one edge: the report counts rows, so count the first piece only ---
+  // (docs/design/levels_plan.md; the extra pieces carry _piece)
+  (function recount(n) {
+    const kv = [...document.querySelectorAll(".rp-kpi")].find((k) => /edges/.test(k.textContent));
+    const wrap = document.getElementById("rp-cls");
+    if (!kv || !wrap || !wrap.querySelector(".rp-ct")) return n > 0 && setTimeout(() => recount(n - 1), 300);
+    const real = rsQuery((p) => !p._piece), props = rsGetProps(real), col = window.RS_CLASS_COL, cnt = {};
+    props.forEach((p) => { const c = p[col]; if (c != null && c !== "") cnt[c] = (cnt[c] || 0) + 1; });
+    kv.querySelector(".rp-kv").textContent = fmt(real.length);
+    wrap.querySelectorAll("label.rp-chk").forEach((lab) => {
+      const ct = lab.querySelector(".rp-ct"); if (!ct) return;
+      ct.textContent = fmt(cnt[lab.textContent.replace(ct.textContent, "").trim()] || 0);
+    });
+  })(20);
+  const ovs = document.getElementById("rp-ovs");
+  const host = ovs ? ovs.parentNode : document.body.appendChild(el("div", "ms-float"));
+
+  // ---- Modes: the roads any ticked mode can use ------------------------------------------------
+  const modes = ["driving", "walking", "cycling"]
+    .map((m) => [m, rsQuery((p) => !p._piece && (p[m] === true || p[m] === "true")).length]).filter(([, n]) => n);
+  const on = new Set(modes.map(([m]) => m)), box = el("div", "ms-modes", '<div class="rp-grp">Modes</div>');
+  for (const [m, n] of modes) box.appendChild(check(m, true, (c) => {
+    c ? on.add(m) : on.delete(m);
+    rsSetModes(on.size === modes.length ? null : [...on]);
+  }, n));
+  // the roads you may not use (private, bus): shown / hidden like a mode (layers.js rsSetAccess)
+  for (const [k, label] of [["private", "private roads"], ["bus", "bus lanes"]])
+    if ((window.RS_ACCESS || {})[k]) box.appendChild(check(label, true, (c) => rsSetAccess(k, c), RS_ACCESS[k]));
+  host.insertBefore(box, ovs);
+
+  // ---- popup off also keeps a layer out of the panel's read-out --------------------------------
+  // the report fills #rp-detail from every rs:select, a road click listing the clickable layers
+  // under it; this listener runs after the report's and redraws it (the report's own markup)
+  // without the layers whose popup is off
+  const detail = document.getElementById("rp-detail"), idle = detail && detail.innerHTML;
+  const rowsOf = (p, only) => (only && only.length ? only : Object.keys(p))
+    .filter((k) => k[0] !== "_" && k !== "lvl" && p[k] != null && p[k] !== "")
+    .map((k) => "<b>" + esc(k) + "</b>: " + esc(p[k])).join("<br>");
+  const popupOn = (label) => { const s = rsGetInteraction(label); return !s || s.popup; };
+  if (detail) document.addEventListener("rs:select", (e) => {
+    const d = e.detail;
+    if (d.overlay) { if (!popupOn(d.overlay)) detail.innerHTML = idle; return; }
+    const ovs = (d.overlays || []).filter((o) => popupOn(o.label));
+    if (ovs.length === (d.overlays || []).length) return;
+    detail.innerHTML = rowsOf(d.properties, d.fields) + ovs.map((o) =>
+      '<hr style="border:none;border-top:1px solid var(--line);margin:6px 0"><span style="color:var(--mut)">'
+      + esc(o.label) + "</span><br>" + rowsOf(o.properties, o.fields)).join("");
+  });
+
+  // ---- per layer: a row with a gear (switches and kinds), the layers grouped by meaning ---------
+  // (docs/design/dashboard_panel.md)
+  const GROUPS = [["Nature and water", ["ocean", "landcover", "institutional", "water", "waterways"]],
+                  ["Buildings and places", ["buildings", "parking", "parking_p", "platform", "bus_station"]],
+                  ["Transport", ["railways", "crossings", "traffic_signals", "bus_stations", "train_stations", "bicycle"]]];
+  const grpOf = (label) => (GROUPS.find(([, l]) => l.includes(label)) || [])[0] || "Other";
+  const rows = ovs ? [...ovs.querySelectorAll("label.rp-chk")] : [];
+  const sets = {};                                  // layer -> its switches / kinds box
+  for (const ov of window.RS_OVERLAYS || []) {
+    const st = rsGetInteraction(ov.label); if (!st) continue;
+    const d = el("div", "ms-set"), sw = el("div", "ms-sw"), cb = {};
+    // a layer that isn't clickable opens no popup: its popup switch waits, greyed
+    const grey = () => { const off = !cb.clickable.checked; cb.popup.disabled = off;
+      cb.popup.parentNode.style.opacity = off ? 0.45 : 1; cb.popup.parentNode.title = off ? "needs clickable" : ""; };
+    for (const k of ["clickable", "tooltip", "popup"]) {
+      const lab = check(k, st[k], (c) => { rsSetInteraction(ov.label, {[k]: c}); grey(); });
+      cb[k] = lab.querySelector("input"); sw.appendChild(lab);
+    }
+    grey();
+    d.appendChild(sw);
+    const counts = window.RS_KINDS[ov.label] || {}, names = Object.keys(counts);
+    if (names.length > 1) {
+      const shown = new Set(names), list = el("div", "ms-kinds"), cbs = {};
+      const apply = () => rsSetKinds(ov.label, shown.size === names.length ? null : [...shown]);
+      const all = el("div", "ms-all", "<a>all</a><a>none</a>");
+      const setAll = (v) => { names.forEach((n) => { cbs[n].querySelector("input").checked = v; v ? shown.add(n) : shown.delete(n); }); apply(); };
+      all.children[0].onclick = () => setAll(true);
+      all.children[1].onclick = () => setAll(false);
+      d.appendChild(all);
+      for (const n of names) {
+        cbs[n] = check(n, true, (c) => { c ? shown.add(n) : shown.delete(n); apply(); }, counts[n]);
+        list.appendChild(cbs[n]);
+      }
+      d.appendChild(list);
+    }
+    sets[ov.label] = d;
+  }
+  const rowOf = (label) => rows.find((r) => r.textContent.trim() === label);
+  const groups = new Map();
+  for (const r of rows) {                           // the report's own rows, in its order, into their group
+    const label = r.textContent.trim(), g = grpOf(label);
+    if (!groups.has(g)) {
+      const det = el("details", "ms-grp"), sum = el("summary", null, "<span>" + esc(g) + '</span><b class="ms-n"></b>');
+      const all = el("span", "ms-all", "<a>all</a><a>none</a>");
+      det.open = g !== "Other"; det.appendChild(sum); sum.appendChild(all);
+      const setAll = (v) => (e) => { e.preventDefault(); for (const q of det.querySelectorAll(".ms-row > label input")) if (q.checked !== v) q.click(); };
+      all.children[0].onclick = setAll(true); all.children[1].onclick = setAll(false);
+      groups.set(g, det);
+    }
+    const det = groups.get(g), wrap = el("div", "ms-row"), set = sets[label];
+    wrap.appendChild(r);
+    if (set) {
+      const gear = el("button", "ms-gear", "⚙"); gear.type = "button"; gear.title = "clicks, kinds";
+      gear.onclick = () => { set.hidden = !set.hidden; gear.classList.toggle("on", !set.hidden); };
+      set.hidden = true; wrap.appendChild(gear); wrap.appendChild(set);
+    }
+    det.appendChild(wrap);
+  }
+  const count = () => groups.forEach((det) => {
+    const q = [...det.querySelectorAll(".ms-row > label input")];
+    det.querySelector(".ms-n").textContent = q.filter((c) => c.checked).length + "/" + q.length;
+  });
+  if (ovs) {
+    const head = ovs.querySelector(".rp-grp"); if (head) head.remove();      // "Layers": the groups say it
+    // Roads first (modes, road types), then the layer groups
+    const roads = el("details", "ms-grp"), cls = document.getElementById("rp-cls");
+    roads.open = true; roads.appendChild(el("summary", null, "<span>Roads</span>"));
+    roads.appendChild(box);
+    if (cls) roads.appendChild(cls);
+    ovs.before(roads);
+    groups.forEach((det) => ovs.appendChild(det));
+    ovs.addEventListener("change", count); count();
+  } else for (const [, det] of groups) host.appendChild(det);
+
+  // ---- the legend repeats Road type when roads are coloured by class: shown for the other colourings ---
+  const co = document.getElementById("rp-co"), lg = document.getElementById("rp-legend");
+  if (co && lg) {
+    const legend = lg.closest("details"), roadType = () => (co.options[co.selectedIndex].text || "") === "Road class";
+    const sync = () => { legend.hidden = roadType(); };
+    co.addEventListener("change", sync); sync();
+  }
+})();

mapstyle-0.3.0/src/mapstyle/levels.py

@@ -0,0 +1,183 @@
+"""The level of a road, drawn only where it is needed (docs/design/levels_plan.md, rule R4).
+
+A road with a ``layer`` tag (and no bridge tag) or a tunnel is drawn at ground level, except for the
+stretch where it really passes over or under another road: lines that cross with no node in common,
+at another level. That stretch, plus a clearance, is a **piece** of the edge drawn in its own band
+(over / under the ground roads) with square ends; the rest of the edge is ground, so every joint is at
+ground level and its casings merge. The database and the ``edge_id`` do not change: only the lines
+sent to the map are cut. Bridges keep roadstyle's own rule.
+"""
+import math
+
+import pandas as pd
+
+# metres from a crossing road's edge to the cut, and the half width of a crossing road by class
+CLEARANCE_M = 4.0
+HALF_WIDTH_M = {"motorway": 6, "trunk": 5.5, "primary": 4.5, "secondary": 4, "tertiary": 3.5, "residential": 3,
+                "unclassified": 3, "living_street": 3, "service": 2, "pedestrian": 2.5, "footway": 1,
+                "path": 1, "cycleway": 1, "steps": 1, "corridor": 1}
+MIN_PIECE_M = 2.0       # a ground piece shorter than this joins the stretch beside it
+END_M = 4.0            # a joint end keeps a ground piece at least this long (the round end of the road meeting it needs it)
+OVERLAP_M = 0.3         # neighbouring pieces overlap by this much each: two square ends that only touch leave a hairline
+
+def _truthy(col):
+    return f"({col} IS NOT NULL AND lower(CAST({col} AS VARCHAR)) NOT IN ('', 'no', 'false', '0'))"
+
+
+def crossing_pairs(con, union):
+    """``(a, b, highway of b)`` edge-id pairs: ``a`` is a road to cut (a plain ``layer`` road or a tunnel) and ``b`` a
+    road at a level that makes ``a`` go over or under it, with no node in common and within about 20 m (``_pieces_of``
+    keeps those whose drawn roads cross or overlap). Also the roads to cut, with their level."""
+    con.execute(f"""
+        CREATE TEMP TABLE e0 AS
+        SELECT edge_id AS eid, any_value(source) AS s, any_value(target) AS t, any_value(layer) AS layer,
+               any_value(bridge) AS bridge, any_value(tunnel) AS tunnel, any_value(highway) AS hw,
+               any_value(geometry) AS g
+        FROM ({union}) GROUP BY edge_id""")
+    con.execute(f"""
+        CREATE TEMP TABLE lv AS
+        SELECT eid, s, t, hw, g, {_truthy('tunnel')} AS is_tunnel, {_truthy('bridge')} AS is_bridge,
+               COALESCE(NULLIF(TRY_CAST(layer AS INTEGER), 0),
+                        CASE WHEN {_truthy('bridge')} THEN 1 WHEN {_truthy('tunnel')} THEN -1 ELSE 0 END) AS l
+        FROM e0""")
+    pairs = con.execute("""
+        SELECT CAST(a.eid AS VARCHAR) AS a, CAST(o.eid AS VARCHAR) AS b, o.hw AS hw
+        FROM lv a JOIN lv o ON o.eid <> a.eid AND ST_DWithin(a.g, o.g, 0.0002)
+             AND a.s NOT IN (o.s, o.t) AND a.t NOT IN (o.s, o.t)
+        WHERE NOT a.is_bridge AND (a.is_tunnel OR a.l <> 0)
+          AND CASE WHEN a.l > 0 THEN o.l >= 0 AND o.l < a.l ELSE o.l >= 0 END""").df()
+    cut = con.execute("SELECT CAST(eid AS VARCHAR) AS eid, l, is_tunnel, s, t FROM lv "
+                      "WHERE NOT is_bridge AND (is_tunnel OR l <> 0)").df()
+    return pairs, cut
+
+
+def _scales(geom):
+    lat = math.radians(geom.centroid.y)
+    return 111320.0 * math.cos(lat), 110574.0
+
+
+def _metric(geom, sx, sy):
+    from shapely import affinity
+    return affinity.scale(geom, xfact=sx, yfact=sy, origin=(0, 0))
+
+
+def _pieces_of(ga, others, band, highway=None, clearance=CLEARANCE_M):
+    """``[(m0, m1, band)]`` in metres along ``ga`` (a lon/lat line of class ``highway``): ground except the stretches
+    where its drawn road crosses or overlaps the drawn road of one of ``others`` (lon/lat lines with their class: no
+    node in common, so they are not connected, only drawn over each other), plus the clearance."""
+    sx, sy = _scales(ga)
+    gm = _metric(ga, sx, sy)
+    total = gm.length
+    spans = []
+    for gb, hw in others:
+        near = gm.intersection(_metric(gb, sx, sy).buffer(HALF_WIDTH_M.get(hw, 3) + HALF_WIDTH_M.get(highway, 1)))
+        if near.is_empty:
+            continue
+        pts = [p for g in getattr(near, "geoms", [near]) for p in (g.boundary.geoms if g.length else [g]) if not p.is_empty]
+        ts = [gm.project(p) for p in pts if p.geom_type == "Point"]
+        if not ts:
+            continue
+        spans.append((min(ts) - clearance, max(ts) + clearance, min(ts), max(ts)))
+    spans.sort()
+    merged = []
+    for s0, s1, r0, r1 in spans:
+        s0, s1 = max(0.0, s0), min(total, s1)
+        if merged and s0 <= merged[-1][1] + MIN_PIECE_M:
+            merged[-1][1] = max(merged[-1][1], s1)
+            merged[-1][3] = max(merged[-1][3], r1)
+        else:
+            merged.append([s0, s1, r0, r1])
+    if merged:                  # a road meeting the end keeps a ground piece there, unless the crossing is right at it
+        first, last = merged[0], merged[-1]
+        if first[0] < END_M:
+            first[0] = max(first[0], min(END_M, first[2] - 0.5))
+        if total - last[1] < END_M:
+            last[1] = min(last[1], max(total - END_M, last[3] + 0.5))
+    merged = [[a, b] for a, b, *_ in merged]
+    out, at = [], 0.0
+    for s0, s1 in merged:
+        if s0 - at >= MIN_PIECE_M:
+            out.append((at, s0, 0))
+        else:
+            s0 = at
+        out.append((s0, s1, band))
+        at = s1
+    if total - at >= MIN_PIECE_M:
+        out.append((at, total, 0))
+    elif out:
+        out[-1] = (out[-1][0], total, out[-1][2])
+    return out or [(0.0, total, 0)]
+
+
+def level_pieces(con, union, geoms, highways):
+    """``({edge_id: [(m0, m1, band), ...]}, tunnel edge ids, edge ids to end square)`` for every road to cut, in order
+    along the edge: ground pieces and the stretches that go over (band 1) or under (band -1) a road. ``geoms`` / ``highways``: ``{edge_id: ...}`` of the
+    db's roads (lon/lat lines, classes). A road that crosses nothing is one ground piece."""
+    pairs, cut = crossing_pairs(con, union)
+    by_a = {a: [] for a in cut["eid"]}
+    for a, b, hw in pairs.itertuples(index=False):
+        if b in geoms:
+            by_a[a].append((geoms[b], hw))
+    out = {}
+    for eid, lvl in zip(cut["eid"], cut["l"]):
+        if eid not in geoms:
+            continue
+        out[eid] = _pieces_of(geoms[eid], by_a.get(eid, []), 1 if lvl > 0 else -1, highways.get(eid))
+    # a stretch that reaches the node (a crossing right at the mouth) leaves no ground piece there: the roads that
+    # meet it there end square, or their round end would show as a ring over the lower stretch
+    nodes = set()
+    for eid, sn, tn in zip(cut["eid"], cut["s"], cut["t"]):
+        parts = out.get(eid)
+        if parts and len(parts) and parts[0][2] != 0:
+            nodes.add(int(sn))
+        if parts and parts[-1][2] != 0:
+            nodes.add(int(tn))
+    square = set()
+    if nodes:
+        ids = ", ".join(str(n) for n in nodes)
+        square = {str(e) for (e,) in con.execute(f"SELECT eid FROM lv WHERE s IN ({ids}) OR t IN ({ids})").fetchall()}
+    return out, {eid for eid, t in zip(cut["eid"], cut["is_tunnel"]) if t}, square - set(out)
+
+
+def with_pieces(roads, pieces, tunnels, square=()):
+    """The roads as drawn: each edge in ``pieces`` becomes its first piece (same row, so the feature index the
+    planner's graphs point to is unchanged) and its other pieces are appended after the last edge, with
+    ``_piece`` set. Columns ``_band`` (the piece's band, else the edge's own) and ``_cap`` (square ends: a stretch
+    that goes over or under, and every piece of a tunnel). ``tunnels``: the set of tunnel edge ids."""
+    from shapely import affinity
+    from shapely.ops import substring
+
+    roads = roads.copy()
+    roads["_piece"] = False
+    roads["_cap"] = roads["edge_id"].isin(square)             # roads meeting a stretch at a node end square
+    extra = []
+    for i, eid in zip(roads.index, roads["edge_id"]):
+        parts = pieces.get(eid)
+        if not parts:
+            continue
+        ga = roads.at[i, "geometry"]
+        sx, sy = _scales(ga)
+        gm = _metric(ga, sx, sy)
+        rows = []
+        last = len(parts) - 1
+        for n, (m0, m1, band) in enumerate(parts):
+            a, b = max(0.0, m0 - OVERLAP_M) if n else m0, min(gm.length, m1 + OVERLAP_M) if n < last else m1
+            line = affinity.scale(substring(gm, a, b), xfact=1 / sx, yfact=1 / sy, origin=(0, 0))
+            rows.append((line, band))
+        own = roads.at[i, "_band"]
+        for n, (line, band) in enumerate(rows):
+            cap = band != 0 or eid in tunnels
+            b = band if pd.isna(own) else own
+            if n == 0:
+                roads.at[i, "geometry"], roads.at[i, "_band"], roads.at[i, "_cap"] = line, b, cap
+            else:
+                r = roads.loc[i].copy()
+                r["geometry"], r["_band"], r["_cap"], r["_piece"] = line, b, cap, True
+                if "k" in r.index:
+                    r["k"] = float("nan")          # the planner's graphs point at the edge's first piece only
+                extra.append(r)
+    if extra:
+        import geopandas as gpd
+        roads = gpd.GeoDataFrame(pd.concat([roads, pd.DataFrame(extra)], ignore_index=True), geometry="geometry",
+                                 crs=roads.crs)
+    return roads