mapstyle 0.3.0__tar.gz → 0.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapstyle
-Version: 0.3.0
+Version: 0.4.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,18 +18,15 @@ Classifier: Topic :: Scientific/Engineering :: Visualization
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: roadstyle>=0.12.0
+Requires-Dist: roadstyle>=0.14.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"
@@ -98,9 +95,9 @@ ms.render_map("monaco.duckdb", dashboard=True).save("dashboard.html") # a dashbo
 - **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 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.
+  under, crossings over their street. The drawing order of the roads is [roadstyle's](https://github.com/Khoshkhah/roadstyle):
+  a casing number and a fill number for every road, read from the database when `duckosm levels` stored them, else computed
+  while the page is made, 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.

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

@@ -60,9 +60,9 @@ ms.render_map("monaco.duckdb", dashboard=True).save("dashboard.html") # a dashbo
 - **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 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.
+  under, crossings over their street. The drawing order of the roads is [roadstyle's](https://github.com/Khoshkhah/roadstyle):
+  a casing number and a fill number for every road, read from the database when `duckosm levels` stored them, else computed
+  while the page is made, 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.

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mapstyle"
-version = "0.3.0"
+version = "0.4.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.12.0",  # the page (casing_level_col / fill_level_col, band_col, directed_col, cap_col)
+    "roadstyle>=0.14.0",  # the page and the drawing order (compute_levels / load_levels, band_col, directed_col, cap_col)
     "duckdb",             # reads the duckOSM db
     "geopandas",
     "pyyaml",             # styles/*.yaml
@@ -31,8 +31,7 @@ dependencies = [
 
 [project.optional-dependencies]
 tiles = ["roadstyle[tiles]"]   # --tiles / render_map(tiles=True)
-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"]
+dev = ["pytest"]
 docs = ["mkdocs>=1.6,<2", "mkdocs-material>=9.5,<10", "mkdocs-llmstxt>=0.5,<0.6"]
 
 [project.urls]

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

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

{mapstyle-0.3.0 → mapstyle-0.4.0}/src/mapstyle/map.py

@@ -374,8 +374,43 @@ def planner_data(db, roads):
     return data
 
 
+def _band(roads):
+    """The band of every road: below (-1 ...), on (0) or over (1 ...) the ground (docs/design/stored_levels.md). It is complete, because roadstyle's ``band_col``
+    replaces the level from the tags: the OSM ``layer`` if that is a number, else 1 for a bridge, -1 for a tunnel, else 0; except for a path with a
+    ``walk_type``: a sidewalk is -1 (under its street) and a crossing 1 (over it). The same as duckOSM's (``duckosm levels``)."""
+    import numpy as np
+    import pandas as pd
+
+    layer = pd.to_numeric(roads["layer"], errors="coerce").fillna(0).astype(int).to_numpy()
+
+    def yes(col):
+        return (roads[col].notna() & ~roads[col].astype(str).isin(["", "no", "None", "nan"])).to_numpy()
+    tags = np.where(layer != 0, layer, np.where(yes("bridge"), 1, np.where(yes("tunnel"), -1, 0)))
+    path = (roads["highway"].isin(PATH_CLASSES) & roads["walk_type"].isin(["sidewalk", "crossing"])).to_numpy()
+    return np.where(path, roads["walk_type"].map({"crossing": 1, "sidewalk": -1}).fillna(0).astype(int).to_numpy(), tags).astype(int)
+
+
+def stored_levels(db, roads):
+    """``roads`` with the four columns of ``visualization.edge_levels`` (``casing_start``, ``casing_level``, ``casing_end``, ``fill_level``), or None when the file has no such
+    table. The numbers must be those computed for these roads with ``duckosm levels``' defaults: if they are not (the file was rebuilt, other options), a ``ValueError`` says what
+    differs and that ``duckosm levels`` must be run again. Nothing is recomputed (docs/design/stored_levels.md)."""
+    import duckdb
+    import roadstyle as rs
+
+    con = duckdb.connect(str(db), read_only=True)
+    try:
+        if not con.execute("SELECT count(*) FROM information_schema.tables WHERE table_schema = 'visualization' AND table_name = 'edge_levels'").fetchone()[0]:
+            return None
+        try:
+            return rs.load_levels(con, roads, band_col="band", order="class")
+        except ValueError as e:
+            raise ValueError(f"{e}; run `duckosm levels {db}` again") from None
+    finally:
+        con.close()
+
+
 def render_map(db, mode=None, layers=True, planner=False, dashboard=False, interaction=None,
-               paths=PATHS, theme="osm", order=True, pieces=False, **kwargs):
+               paths=PATHS, theme="osm", pieces=False, **kwargs):
     """``rs.render_edges`` of the db's roads (all modes' edges) in the ``mode``'s style, over the
     ``features.*`` base map, with mapstyle's rs* functions (``rsSetModes``, ``rsSetKinds``,
     ``rsSetInteraction``: layers.js). ``layers``: True = every styles/layers.yaml layer, a list of
@@ -386,15 +421,16 @@ def render_map(db, mode=None, layers=True, planner=False, dashboard=False, inter
     kind and interaction filters (docs/design/dashboard.md). ``mode``: which network stands out
     (all, driving, walking, cycling); default all (the planner too: in the walking look a road's two directions are one line, so only one can be clicked).
     ``theme``: the whole map's colours, ``osm`` (default) or a styles/themes/*.yaml
-    (docs/design/themes.md). ``order``: give each road the position in the drawing order of its casing and of its fill
-    (``mapstyle.node_levels``, docs/design/node_levels.md; roadstyle's ``casing_level_col`` / ``fill_level_col``), so that connected
-    roads merge cleanly and a road that passes over another is drawn over it; False: roadstyle's own bands. ``pieces``: the other
-    approach, cutting a road with a level into pieces (docs/design/levels_plan.md); not the default, and not with ``order``.
+    (docs/design/themes.md). The drawing order of the roads is roadstyle's (docs/design/stored_levels.md): every road has a casing number and a fill number, so that connected
+    roads merge cleanly and a road that passes over another is drawn over it. They are read from ``visualization.edge_levels`` when the file has them (``duckosm levels``),
+    else roadstyle computes them while it renders. ``pieces``: the other approach, cutting a road with a level into pieces (docs/design/levels_plan.md); not the default.
     The base map is ``blank``: the db's own layers are the map (the sea is ``features.ocean``).
     ``kwargs`` go to roadstyle
     (``basemap``, ``tiles``, ``arrows``, ...)."""
     import roadstyle as rs
 
+    if "order" in kwargs:
+        raise ValueError("render_map(order=...) is removed: the drawing order is roadstyle's (docs/design/stored_levels.md)")
     mode = mode or "all"
     if planner and kwargs.get("tiles"):
         raise ValueError("planner=True can't use tiles=True: the planner snaps to the roads in the page")
@@ -436,32 +472,24 @@ def render_map(db, mode=None, layers=True, planner=False, dashboard=False, inter
             "Road class": {}, "Modes": {"color_by": "modes", "colors": load_style("modes")["mode_colors"]}})
         html += f"<script>{(_HERE / 'dashboard.js').read_text()}</script>"
         render = rs.render_report
-    # a crossing (the zebra) draws over the street it crosses, a sidewalk under the street beside
-    # it, casings included (roadstyle's band_col; roadstyle/docs/design/draw_order_per_edge.md).
-    # Paths only: duckOSM also marks a car road "sidewalk" when you walk along its own sidewalk,
-    # and that road must stay with the other streets (708 road edges in Monaco).
-    path = roads["highway"].isin(PATH_CLASSES)
-    roads["_band"] = roads["walk_type"].map({"crossing": 1, "sidewalk": -1}).where(path)
-    kw["band_col"], kw["cap_col"] = "_band", "_cap"
-    roads["_cap"] = False
+    roads["band"] = _band(roads)
     if pieces:
-        # a road with a level (a layer tag, a tunnel) is ground except where it really passes over or under a road: cut
-        # into pieces for drawing, square-ended (docs/design/levels_plan.md; roadstyle's cap_col)
+        # a road with a level (a layer tag, a tunnel) is ground except where it really passes over or under a road: cut into pieces for drawing, square-ended
+        # (docs/design/levels_plan.md; roadstyle's cap_col). The band of a piece is ``_band``; a crossing over its street, a sidewalk under it (paths only)
+        path = roads["highway"].isin(PATH_CLASSES)
+        roads["_band"] = roads["walk_type"].map({"crossing": 1, "sidewalk": -1}).where(path)
+        kw["band_col"], kw["cap_col"] = "_band", "_cap"
+        roads["_cap"] = False
         from mapstyle.levels import with_pieces
         roads = with_pieces(roads, *load_pieces(db, roads))
-    elif order and kwargs.get("tiles"):
-        log.warning("tiles=True: the drawing order (order=True) is not supported with vector tiles yet; roadstyle's bands are used")
-    elif order:
-        # the drawing order of the casing and of the fill of every road (docs/design/node_levels.md). The positions are doubled,
-        # so a crossing (the zebra) can sit between the ground and the next position, over its street with its halo, and a mapped
-        # sidewalk under it (what band_col did)
-        from mapstyle.node_levels import compute, with_cuts
-        roads = with_cuts(roads, compute(db))
-        for band, pos in ((1, 1), (-1, -1)):
-            m_ = roads["_band"] == band
-            roads.loc[m_, ["_cl", "_fl"]] = pos
-        kw["casing_level_col"], kw["fill_level_col"] = "_cl", "_fl"
-        kw.pop("cap_col")
+    else:
+        # the drawing order: the numbers stored in the file, else roadstyle computes them from the band (docs/design/stored_levels.md)
+        stored = stored_levels(db, roads)
+        if stored is None:
+            kw["band_col"] = "band"
+        else:
+            roads = stored
+            kw.update(casing_level_col="casing_level", fill_level_col="fill_level", casing_start_col="casing_start", casing_end_col="casing_end")
     # duckOSM stores every path, and a one-way street's walking-only reverse, as a reverse edge too:
     # roadstyle draws a pair as two lanes only when both edges are directed (directed_col,
     # twin_ends.md)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapstyle
-Version: 0.3.0
+Version: 0.4.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,18 +18,15 @@ Classifier: Topic :: Scientific/Engineering :: Visualization
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: roadstyle>=0.12.0
+Requires-Dist: roadstyle>=0.14.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"
@@ -98,9 +95,9 @@ ms.render_map("monaco.duckdb", dashboard=True).save("dashboard.html") # a dashbo
 - **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 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.
+  under, crossings over their street. The drawing order of the roads is [roadstyle's](https://github.com/Khoshkhah/roadstyle):
+  a casing number and a fill number for every road, read from the database when `duckosm levels` stored them, else computed
+  while the page is made, 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.

{mapstyle-0.3.0 → mapstyle-0.4.0}/src/mapstyle.egg-info/SOURCES.txt

@@ -6,7 +6,6 @@ src/mapstyle/dashboard.js
 src/mapstyle/layers.js
 src/mapstyle/levels.py
 src/mapstyle/map.py
-src/mapstyle/node_levels.py
 src/mapstyle/patterns.py
 src/mapstyle/planner.html
 src/mapstyle/style.py

{mapstyle-0.3.0 → mapstyle-0.4.0}/src/mapstyle.egg-info/requires.txt

@@ -1,4 +1,4 @@
-roadstyle>=0.12.0
+roadstyle>=0.14.0
 duckdb
 geopandas
 pyyaml
@@ -6,15 +6,11 @@ pillow
 
 [dev]
 pytest
-ortools>=9.10
 
 [docs]
 mkdocs<2,>=1.6
 mkdocs-material<10,>=9.5
 mkdocs-llmstxt<0.6,>=0.5
 
-[solver]
-ortools>=9.10
-
 [tiles]
 roadstyle[tiles]

{mapstyle-0.3.0 → mapstyle-0.4.0}/tests/test_map.py

@@ -145,101 +145,63 @@ def test_roads_with_a_level_are_cut_into_pieces(monaco, monkeypatch):
         assert whole[eid] - 1e-9 <= rows.geometry.length.sum() <= whole[eid] + extra + 1e-9
     off = {}
     monkeypatch.setattr(rs, "render_edges", lambda g, **kw: off.update(g=g) or SimpleNamespace(_tpl="</body>"))
-    render_map(monaco, layers=False, order=False, pieces=False)
-    assert len(off["g"]) == n and not off["g"]["_cap"].any()
+    render_map(monaco, layers=False, pieces=False)
+    assert len(off["g"]) == n and "_cap" not in off["g"]
 
 
-def _tiny_db(path, edges):
-    """A duckOSM-like db with just ``<mode>.edges``: ``edges`` = [(mode, highway, name, [(x, y) in metres], layer, bridge, tunnel)]."""
-    import math
+def test_the_band_is_complete(monaco):
+    """docs/design/stored_levels.md: roadstyle's band_col replaces the level from the tags, so the band has a value for every road: the layer, else a bridge 1 and a tunnel -1;
+    a path's sidewalk -1 and crossing 1."""
+    from mapstyle.map import _band
+    roads = load_roads(monaco)
+    band = _band(roads)
+    assert len(band) == len(roads) and set(band) >= {-1, 0, 1}
+    tunnel = roads["tunnel"].notna() & ~roads["tunnel"].astype(str).isin(["", "no"]) & roads["layer"].isna() & ~roads["walk_type"].isin(["sidewalk", "crossing"])
+    assert tunnel.any() and (band[tunnel.to_numpy()] == -1).all()                # a tunnel with no layer tag is below the ground
+    path = roads["highway"].isin(["footway", "path", "cycleway", "steps", "pedestrian", "bridleway", "corridor"])
+    assert (band[(path & (roads["walk_type"] == "crossing")).to_numpy()] == 1).all() and (band[(path & (roads["walk_type"] == "sidewalk")).to_numpy()] == -1).all()
 
-    import duckdb
-    lon0, lat0 = 7.42, 43.73
-    ll = lambda x, y: (lon0 + x / (111320 * math.cos(math.radians(lat0))), lat0 + y / 110574)  # noqa: E731
-    c = duckdb.connect(str(path))
-    c.execute("INSTALL spatial; LOAD spatial;")
-    node = {}
-    for m in MODES:
-        c.execute(f"CREATE SCHEMA {m}")
-        c.execute(f"CREATE TABLE {m}.edges (edge_id BIGINT, source BIGINT, target BIGINT, osm_id BIGINT, highway VARCHAR, name VARCHAR, "
-                  "bridge VARCHAR, tunnel VARCHAR, layer VARCHAR, oneway BOOLEAN, geometry GEOMETRY)")
-    for i, (mode, hw, nm, pts, lay, br, tu) in enumerate(edges, 1):
-        nid = lambda q: node.setdefault((round(q[0], 3), round(q[1], 3)), len(node) + 1)  # noqa: E731
-        wkt = "LINESTRING(" + ",".join("%.8f %.8f" % ll(*q) for q in pts) + ")"
-        c.execute(f"INSERT INTO {mode}.edges VALUES (?,?,?,?,?,?,?,?,?,false,ST_GeomFromText(?))",
-                  [1000 + i, nid(pts[0]), nid(pts[-1]), 500 + i, hw, nm, "yes" if br else None, "yes" if tu else None,
-                   str(lay) if lay else None, wkt])
-    c.close()
-    return path
-
-
-def _levels_of(db):
-    from mapstyle.node_levels import compute
-    lv = compute(db)
-    return lv, (lambda e: lv.intervals.get(str(e), (0, 0)))
-
-
-def test_a_raised_path_over_a_street_joined_to_ground_paths(tmp_path):
-    """The scene of docs/design/node_levels.md: a path with a layer tag joins two ground paths and passes over a street. The
-    intervals of roads that share a node intersect; the upper road's casing comes after the street's fill."""
-    R, P = "residential", "pedestrian"
-    db = _tiny_db(tmp_path / "ramp.duckdb", [
-        ("walking", P, "ground", [(-40, 0), (0, 0)], 0, 0, 0), ("walking", P, "ground", [(0, 0), (-20, -28)], 0, 0, 0),
-        ("walking", P, "raised", [(0, 0), (36, 14.4)], 1, 0, 0), ("driving", R, "street", [(17, -30), (17, 40)], 0, 0, 0)])
-    lv, iv = _levels_of(db)
-    ground1, ground2, raised, street = (iv(1001 + i) for i in range(4))
-    assert lv.info["overpass_pairs"] == 1 and lv.info["given_up"] == 0
-    assert raised[0] > street[1]                                      # over the street, its casing after the street's fill
-    for ground in (ground1, ground2):                                 # the ground paths meet the raised road at a node
-        assert ground[0] <= raised[1] and raised[0] <= ground[1]
-    assert not lv.cuts
-
-
-def test_a_tunnel_under_a_street_and_no_overpass_without_a_crossing(tmp_path):
-    R = "residential"
-    db = _tiny_db(tmp_path / "tunnel.duckdb", [
-        ("driving", R, "road", [(-30, 0), (-12, 0)], 0, 0, 0), ("driving", R, "tunnel", [(-12, 0), (12, 0)], -1, 0, 1),
-        ("driving", R, "road", [(12, 0), (30, 0)], 0, 0, 0), ("driving", R, "street", [(0, -40), (0, 40)], 0, 0, 0)])
-    lv, iv = _levels_of(db)
-    mouth1, tunnel, mouth2, street = (iv(1001 + i) for i in range(4))
-    assert lv.info["overpass_pairs"] == 1 and street[0] > tunnel[1]
-    assert mouth1[0] <= tunnel[1] and tunnel[0] <= mouth1[1] and mouth2[0] <= tunnel[1] and tunnel[0] <= mouth2[1]
-    only = _tiny_db(tmp_path / "flat.duckdb", [("driving", R, "a", [(-30, 0), (0, 0)], 0, 0, 0), ("driving", R, "b", [(0, 0), (30, 0)], 1, 0, 0)])
-    lv, iv = _levels_of(only)
-    assert lv.info["overpass_pairs"] == 0 and not lv.intervals                  # nothing crosses: every road stays at 0
-
-
-def test_node_levels_without_a_solver_and_on_monaco(monaco):
-    """The heuristic runs without OR-Tools; on Monaco every overpass pair is satisfied after the conflict fixes."""
-    from mapstyle.node_levels import compute
-    h = compute(monaco, solver=False)
-    assert h.info["solver"] is False and h.info["overpass_pairs"] > 100
-    s = compute(monaco)
-    assert s.info["unsatisfied"] == 0 and s.info["given_up"] >= s.info["dropped"] and s.info["levels"] <= 12
-    assert s.info["given_up"] <= 8                                         # 3 in the sample; a few for another build of it
-
-
-def test_the_default_page_draws_the_order_of_the_roads(monaco, monkeypatch):
-    """render_map gives roadstyle ``casing_level_col`` / ``fill_level_col``: even positions from the intervals, a crossing at 1 and a
-    mapped sidewalk at -1; a road cut into pieces keeps its row and appends the other pieces with ``_piece``."""
-    seen = {}
+
+def _seen(monkeypatch, db, **kw):
+    """The arguments and the roads that render_map gives roadstyle's render_edges."""
     from types import SimpleNamespace
-    monkeypatch.setattr(rs, "render_edges", lambda g, **kw: seen.update(kw, g=g) or SimpleNamespace(_tpl="</body>"))
-    render_map(monaco, layers=False)
-    g, base = seen["g"], load_roads(monaco)
-    assert seen["casing_level_col"] == "_cl" and seen["fill_level_col"] == "_fl" and "cap_col" not in seen
-    n = len(base)
-    assert list(g["edge_id"].iloc[:n]) == list(base["edge_id"]) and g["_piece"].iloc[n:].all()
-    assert (g["_cl"] <= g["_fl"]).all()
-    cross, side = g["_band"] == 1, g["_band"] == -1
-    assert cross.any() and side.any()
-    assert set(g.loc[cross, "_cl"]) == {1} and set(g.loc[cross, "_fl"]) == {1} and set(g.loc[side, "_cl"]) == {-1}
-    rest = g[~cross & ~side]
-    assert (rest["_cl"] % 2 == 0).all() and (rest["_fl"] % 2 == 0).all()   # the odd positions stay free
-    off = {}
-    monkeypatch.setattr(rs, "render_edges", lambda g, **kw: off.update(kw, g=g) or SimpleNamespace(_tpl="</body>"))
-    render_map(monaco, layers=False, order=False)
-    assert "casing_level_col" not in off and len(off["g"]) == n
+    seen = {}
+    monkeypatch.setattr(rs, "render_edges", lambda g, **k: seen.update(k, g=g) or SimpleNamespace(_tpl="</body>"))
+    render_map(db, layers=False, **kw)
+    return seen
+
+
+def test_without_stored_levels_roadstyle_computes_the_order(monaco, monkeypatch):
+    """docs/design/stored_levels.md: a file without visualization.edge_levels: roadstyle computes the numbers from the complete band; every road is drawn whole."""
+    seen = _seen(monkeypatch, monaco)
+    assert seen["band_col"] == "band" and "casing_level_col" not in seen and "cap_col" not in seen
+    assert len(seen["g"]) == len(load_roads(monaco)) and "band" in seen["g"] and not seen["g"]["band"].isna().any()
+
+
+def test_stored_levels_are_read_and_a_stale_table_is_an_error(monaco, tmp_path, monkeypatch):
+    """With the table (duckosm levels) the page is drawn with its numbers; a table computed with other options is an error that says to run duckosm levels again."""
+    import shutil
+
+    if not DUCKOSM_EXE.exists():
+        pytest.skip("needs duckOSM's duckosm")
+    db = tmp_path / "stored.duckdb"
+    shutil.copy(monaco, db)
+    done = subprocess.run([DUCKOSM_EXE, "levels", str(db)], capture_output=True, text=True)
+    if done.returncode:
+        pytest.skip(f"duckosm levels is not available (duckOSM 0.2.0 with roadstyle 0.13.1 is needed): {done.stderr[-200:]}")
+    seen = _seen(monkeypatch, db)
+    assert [seen[k] for k in ("casing_level_col", "fill_level_col", "casing_start_col", "casing_end_col")] == ["casing_level", "fill_level", "casing_start", "casing_end"]
+    assert "band_col" not in seen and (seen["g"]["casing_level"] <= seen["g"]["fill_level"]).all()
+    assert len(seen["g"]) == len(load_roads(db))
+    assert _seen(monkeypatch, db, tiles=True)["casing_level_col"] == "casing_level"          # also with vector tiles
+    subprocess.run([DUCKOSM_EXE, "levels", str(db), "--no-min-positions"], check=True, capture_output=True)
+    with pytest.raises(ValueError, match="duckosm levels"):
+        render_map(db, layers=False)                                                           # the file's numbers were computed with other options: never recomputed silently
+
+
+def test_the_argument_order_is_removed(monaco):
+    with pytest.raises(ValueError, match="removed"):
+        render_map(monaco, layers=False, order=True)
 
 
 def test_pieces_of_one_road():
@@ -466,7 +428,7 @@ def test_grey_theme_is_muted_except_the_water_and_green_hints():
 
 
 def test_theme_osm_is_todays_page_and_an_unknown_theme_names_the_choices(monaco):
-    assert render_map(monaco, layers=False, order=False).html == render_map(monaco, layers=False, order=False, theme="osm").html
+    assert render_map(monaco, layers=False).html == render_map(monaco, layers=False, theme="osm").html
     with pytest.raises(ValueError, match="unknown theme 'nope'; choose from \\('osm', 'google', 'grey'\\)"):
         render_map(monaco, theme="nope")
     html = render_map(monaco, theme="grey").html

mapstyle-0.3.0/src/mapstyle/node_levels.py

@@ -1,526 +0,0 @@
-"""The order in which each road's casing and fill are drawn (docs/design/node_levels.md).
-
-Every road (both directions of a segment together) gets an interval ``[a, b]`` of integers: ``a`` is the position in the
-drawing order where its casing is drawn and ``b`` where its fill is drawn; at each position all casings come before all fills.
-
-* roads that share a node have intersecting intervals (so they merge cleanly);
-* an overpass (two roads whose lines cross, no node in common, different level tags) has disjoint intervals, the upper one
-  later, so the upper road is drawn over the lower one with its own casing; an overpass that cannot be satisfied is given up.
-
-Found with OR-Tools CP-SAT (``pip install mapstyle[solver]``); without it a heuristic is used. Only the roads within a few hops
-of an overpass are in the problem; every other road is at position 0 (``[0, 0]``).
-
-Two conflict-driven fixes, applied only where a conflict is left (docs/design/node_levels.md): a pair whose crossing is within
-``EPS_NODE_M`` of an end node of either road is not an overpass; otherwise the road that changes level along itself is cut
-at its crossing.
-"""
-import logging
-from collections import defaultdict
-
-log = logging.getLogger(__name__)
-
-LO, HI = -20, 20          # the ends of an interval are integers in [LO, HI]
-EPS_NODE_M = 0.3          # a crossing this close to an end node of either road is a junction missing a node, not an overpass
-HOPS = 4                  # roads this many nodes away from an overpass road are in the problem; the others are [0, 0]
-M_PER_DEG = 95000.0       # rough: only used to compare distances along one road
-
-
-def have_solver():
-    try:
-        import ortools  # noqa: F401
-        return True
-    except ImportError:
-        return False
-
-
-# ---- the data -------------------------------------------------------------------------------------------------------
-def load(con, union):
-    """``(roads, lk, pairs)``. ``roads``: ``{road id: (s, t, level, length_m)}``, a road being the directed edges with the same
-    two end nodes and the same line; ``lk``: ``{edge id: road id}`` for the edges of a road with more than one; ``pairs``: the
-    overpass pairs ``(upper, lower)`` as road ids. ``con`` has the spatial extension loaded."""
-    t = lambda c: f"({c} IS NOT NULL AND lower(CAST({c} AS VARCHAR)) NOT IN ('', 'no', 'false', '0'))"  # noqa: E731
-    o = "ORDER BY mode IS NULL, mode, pmode"
-    con.execute(f"""CREATE TEMP TABLE nl_e0 AS SELECT edge_id AS eid, first(source {o}) AS s, first(target {o}) AS t,
-        first(layer {o}) AS layer, first(bridge {o}) AS bridge, first(tunnel {o}) AS tunnel, first(geometry {o}) AS g
-        FROM ({union}) GROUP BY edge_id""")
-    con.execute(f"""CREATE TEMP TABLE nl_lv AS SELECT eid, s, t, g,
-        COALESCE(NULLIF(TRY_CAST(layer AS INTEGER), 0), CASE WHEN {t('bridge')} THEN 1 WHEN {t('tunnel')} THEN -1 ELSE 0 END) AS l
-        FROM nl_e0""")
-    # candidate pairs through a grid (a spatial join over a whole county takes minutes), then the exact test
-    cs = 0.001
-    con.execute(f"""CREATE TEMP TABLE nl_bb AS SELECT eid, l, CAST(floor(ST_XMin(g)/{cs}) AS BIGINT) cx0, CAST(floor(ST_XMax(g)/{cs}) AS BIGINT) cx1,
-        CAST(floor(ST_YMin(g)/{cs}) AS BIGINT) cy0, CAST(floor(ST_YMax(g)/{cs}) AS BIGINT) cy1 FROM nl_lv""")
-    con.execute("CREATE TEMP TABLE nl_cx AS SELECT eid, l, unnest(range(cx0, cx1 + 1)) i, cy0, cy1 FROM nl_bb")
-    con.execute("CREATE TEMP TABLE nl_cells AS SELECT eid, l, i, unnest(range(cy0, cy1 + 1)) j FROM nl_cx")
-    con.execute("""CREATE TEMP TABLE nl_cand AS SELECT DISTINCT a.eid ea, o.eid eo FROM nl_cells a JOIN nl_cells o
-        ON a.i = o.i AND a.j = o.j AND a.eid <> o.eid AND a.l <> 0 AND a.l <> o.l AND (o.l = 0 OR a.eid < o.eid)""")
-    raw = con.execute("""SELECT CASE WHEN a.l > o.l THEN a.eid ELSE o.eid END, CASE WHEN a.l > o.l THEN o.eid ELSE a.eid END
-        FROM nl_cand c JOIN nl_lv a ON a.eid = c.ea JOIN nl_lv o ON o.eid = c.eo
-        WHERE a.s NOT IN (o.s, o.t) AND a.t NOT IN (o.s, o.t) AND ST_Crosses(a.g, o.g)""").fetchall()
-    # roads: the two directions of a segment (same end nodes, same line reversed); the road id is the smallest edge id
-    grp = con.execute("""SELECT a.eid, min(o.eid) FROM nl_lv a JOIN nl_lv o ON least(a.s, a.t) = least(o.s, o.t)
-        AND greatest(a.s, a.t) = greatest(o.s, o.t) AND ST_Equals(a.g, o.g) GROUP BY a.eid""").fetchall()
-    lk = {str(a): str(b) for a, b in grp if a != b}
-    need = {str(x) for pr in raw for x in pr}
-    need |= {lk.get(x, x) for x in need}
-    roads = {}
-    ids = ", ".join(sorted(need)) or "0"
-    for e, s, t_, l, ln in con.execute(f"SELECT eid, s, t, l, ST_Length(g) FROM nl_lv WHERE eid IN ({ids})").fetchall():
-        roads[str(e)] = (s, t_, int(l), ln * M_PER_DEG)
-    pairs = sorted({(lk.get(str(u), str(u)), lk.get(str(l), str(l))) for u, l in raw} - {(x, x) for x in roads})
-    return roads, lk, pairs
-
-
-def _neighbourhood(con, seeds, hops, lk):
-    """Roads (as representative edge ids) within ``hops`` nodes of the roads ``seeds``: ``{road: (s, t, level, length_m)}``."""
-    rows = {}
-    frontier = set()
-    for e in seeds:
-        r = con.execute(f"SELECT eid, s, t, l, ST_Length(g) FROM nl_lv WHERE eid = {e}").fetchone()
-        rows[str(r[0])] = (r[1], r[2], int(r[3]), r[4] * M_PER_DEG)
-        frontier |= {r[1], r[2]}
-    seen = set(frontier)
-    for _ in range(hops):
-        if not frontier:
-            break
-        ns = ", ".join(str(n) for n in frontier)
-        new = set()
-        for e, s, t, l, ln in con.execute(f"SELECT eid, s, t, l, ST_Length(g) FROM nl_lv WHERE s IN ({ns}) OR t IN ({ns})").fetchall():
-            if str(e) not in lk:                    # the other direction of a road is not a road of its own
-                rows[str(e)] = (s, t, int(l), ln * M_PER_DEG)
-            new |= {s, t}
-        frontier = new - seen
-        seen |= new
-    return rows
-
-
-def join_pairs(items):
-    at = defaultdict(list)
-    for e, (s, t, *_) in items.items():
-        at[s].append(e)
-        if t != s:
-            at[t].append(e)
-    out = set()
-    for es in at.values():
-        for i in range(len(es)):
-            for j in range(i + 1, len(es)):
-                out.add((es[i], es[j]) if es[i] < es[j] else (es[j], es[i]))
-    return sorted(out)
-
-
-# ---- the models -----------------------------------------------------------------------------------------------------
-def _model(items, pairs, fixed, lits=False):
-    from ortools.sat.python import cp_model
-    m = cp_model.CpModel()
-    a = {e: m.NewIntVar(LO, HI, "") for e in items}
-    b = {e: m.NewIntVar(LO, HI, "") for e in items}
-    for e in items:
-        m.Add(a[e] <= b[e])
-    for e, (lo, hi) in fixed.items():
-        m.Add(a[e] == lo)
-        m.Add(b[e] == hi)
-    for x, y in join_pairs(items):
-        m.Add(a[x] <= b[y])
-        m.Add(a[y] <= b[x])
-    return m, a, b
-
-
-def _solve(m, limit, workers=8):
-    from ortools.sat.python import cp_model
-    sv = cp_model.CpSolver()
-    sv.parameters.max_time_in_seconds = limit
-    sv.parameters.num_workers = workers
-    return sv, sv.Solve(m), cp_model
-
-
-def solve_penalty(items, pairs, boundary, limit=60.0, hint=None):
-    """Minimise the number of overpass pairs given up. ``boundary``: roads that touch a road outside the problem must contain 0.
-    Returns ``({road: (a, b)}, [pairs given up], status)``."""
-    m, a, b = _model(items, pairs, {})
-    for e in boundary:
-        m.Add(a[e] <= 0)
-        m.Add(b[e] >= 0)
-    v = []
-    for i, (u, l) in enumerate(pairs):
-        q = m.NewBoolVar("")
-        v.append(q)
-        m.Add(b[l] + 1 <= a[u]).OnlyEnforceIf(q.Not())
-    if hint:
-        for e, (lo, hi) in hint.items():
-            m.AddHint(a[e], max(LO, min(HI, lo)))
-            m.AddHint(b[e], max(LO, min(HI, hi)))
-    m.Minimize(sum(v))
-    sv, st, cp = _solve(m, limit)
-    if st not in (cp.OPTIMAL, cp.FEASIBLE):
-        return None, [], sv.StatusName(st)
-    out = {e: (sv.Value(a[e]), sv.Value(b[e])) for e in items}
-    return out, [pairs[i] for i, q in enumerate(v) if sv.Value(q)], sv.StatusName(st)
-
-
-def solve_hard(items, pairs, boundary, limit=60.0, rounds=20):
-    """The overpass pairs as hard constraints. Infeasible: the conflicting sets of pairs (unsatisfiable cores, through assumptions),
-    one pair released per round until it is feasible. Returns ``(status of the first solve, [cores], [released pairs])``."""
-    released, cores, first = [], [], None
-    for _ in range(rounds):
-        m, a, b = _model(items, pairs, {})
-        for e in boundary:
-            m.Add(a[e] <= 0)
-            m.Add(b[e] >= 0)
-        lits, names = [], []
-        gone = set(released)
-        for u, l in pairs:
-            if (u, l) in gone:
-                continue
-            q = m.NewBoolVar("")
-            m.Add(b[l] + 1 <= a[u]).OnlyEnforceIf(q)
-            lits.append(q)
-            names.append((u, l))
-        m.AddAssumptions(lits)
-        sv, st, cp = _solve(m, limit)
-        first = first or sv.StatusName(st)
-        if st in (cp.OPTIMAL, cp.FEASIBLE):
-            return first, cores, released
-        idx = {lit.Index(): i for i, lit in enumerate(lits)}
-        core = [names[idx[c]] for c in sv.SufficientAssumptionsForInfeasibility() if c in idx]
-        if not core:
-            return first, cores, released
-        cores.append(core)
-        released.append(core[0])
-    return first, cores, released
-
-
-def solve_fixed(items, pairs, fixed, boundary, limit=60.0):
-    """A feasible assignment, hard pairs; roads in ``fixed`` keep their interval; the others as short as possible."""
-    m, a, b = _model(items, pairs, fixed)
-    for e in boundary:
-        m.Add(a[e] <= 0)
-        m.Add(b[e] >= 0)
-    for u, l in pairs:
-        m.Add(b[l] + 1 <= a[u])
-    m.Minimize(sum(b[e] - a[e] for e in items if e not in fixed))
-    sv, st, cp = _solve(m, limit)
-    if st not in (cp.OPTIMAL, cp.FEASIBLE):
-        return None
-    return {e: (sv.Value(a[e]), sv.Value(b[e])) for e in items}
-
-
-def compact(items, pairs, boundary, given_up, limit=60.0):
-    """Keep at most ``given_up`` overpasses given up and make the intervals as short as possible (fewer distinct numbers)."""
-    m, a, b = _model(items, pairs, {})
-    for e in boundary:
-        m.Add(a[e] <= 0)
-        m.Add(b[e] >= 0)
-    v = []
-    for u, l in pairs:
-        q = m.NewBoolVar("")
-        v.append(q)
-        m.Add(b[l] + 1 <= a[u]).OnlyEnforceIf(q.Not())
-    m.Add(sum(v) <= given_up)
-    m.Minimize(sum(b[e] - a[e] for e in items))
-    sv, st, cp = _solve(m, limit)
-    if st not in (cp.OPTIMAL, cp.FEASIBLE):
-        return None, []
-    return ({e: (sv.Value(a[e]), sv.Value(b[e])) for e in items}, [pairs[i] for i, q in enumerate(v) if sv.Value(q)])
-
-
-def heuristic(items, pairs):
-    """Without a solver: a level for each node (all start at 0; a raised road is lifted, any other road sunk, until every pair that
-    is not in a cycle is satisfied); a road's interval is the lowest to the highest level of its two nodes."""
-    sccs = _scc(pairs, items)
-    keep = [(u, l) for u, l in pairs if not any(sccs.get(nl) == sccs.get(nu) for nu in items[u][:2] for nl in items[l][:2])]
-    p = defaultdict(int)
-    for _ in range(100):
-        moved = False
-        for u, l in keep:
-            for nu in items[u][:2]:
-                for nl in items[l][:2]:
-                    if p[nu] > p[nl]:
-                        continue
-                    if items[u][2] > 0:
-                        p[nu] = p[nl] + 1
-                    else:
-                        p[nl] = p[nu] - 1
-                    moved = True
-        if not moved:
-            break
-    out = {e: (max(LO, min(HI, min(p[s], p[t]))), max(LO, min(HI, max(p[s], p[t])))) for e, (s, t, *_ ) in items.items()}
-    return out, [pr for pr in pairs if pr not in set(keep)]
-
-
-def _scc(pairs, items):
-    g = defaultdict(list)
-    for u, l in pairs:
-        for nu in items[u][:2]:
-            for nl in items[l][:2]:
-                g[nl].append(nu)
-    nodes = set(g) | {x for vs in g.values() for x in vs}
-    index, low, on, stack, comp, c = {}, {}, set(), [], {}, [0]
-    for root in nodes:
-        if root in index:
-            continue
-        work = [(root, iter(g.get(root, ())))]
-        index[root] = low[root] = len(index)
-        stack.append(root)
-        on.add(root)
-        while work:
-            v, it = work[-1]
-            for w in it:
-                if w not in index:
-                    index[w] = low[w] = len(index)
-                    stack.append(w)
-                    on.add(w)
-                    work.append((w, iter(g.get(w, ()))))
-                    break
-                if w in on:
-                    low[v] = min(low[v], index[w])
-            else:
-                work.pop()
-                if work:
-                    low[work[-1][0]] = min(low[work[-1][0]], low[v])
-                if low[v] == index[v]:
-                    while True:
-                        w = stack.pop()
-                        on.discard(w)
-                        comp[w] = c[0]
-                        if w == v:
-                            break
-                    c[0] += 1
-    return comp
-
-
-# ---- the whole computation ------------------------------------------------------------------------------------------
-class Levels:
-    """``intervals``: ``{edge_id: (casing, fill)}`` for every directed edge that is not ``(0, 0)`` (anything missing is ``(0, 0)``);
-    ``cuts``: ``{road id: {"bounds": [m...], "intervals": [(casing, fill)...], "edges": [edge ids]}}``, the roads to draw in pieces
-    (piece i runs from ``bounds[i]`` to ``bounds[i + 1]`` metres along the road's line); ``info``: counts and timing."""
-
-    def __init__(self, intervals, cuts, info):
-        self.intervals, self.cuts, self.info = intervals, cuts, info
-
-
-def _near_node(geom, u, l, eps=EPS_NODE_M):
-    from shapely.geometry import Point
-    x = geom[u].intersection(geom[l])
-    pts = [] if x.is_empty else (list(x.geoms) if hasattr(x, "geoms") else [x])
-    return any(min(Point(g.coords[0]).distance(q), Point(g.coords[-1]).distance(q)) * M_PER_DEG < eps
-               for g in (geom[u], geom[l]) for q in pts)
-
-
-def _cut_positions(line, uppers, geom, clear=6.0):
-    """Where to cut ``line`` so that one piece (the one crossing the upper roads) is separate from the node ends: just before the
-    first crossing and just after the last, never into a node and never past a crossing, as far as ``clear`` metres."""
-    ts = []
-    for u in uppers:
-        x = line.intersection(geom[u])
-        pts = [] if x.is_empty else (list(x.geoms) if hasattr(x, "geoms") else [x])
-        ts += [line.project(q) * M_PER_DEG for q in pts]
-    length = line.length * M_PER_DEG
-    cuts = []
-    if ts:
-        t_min, t_max = min(ts), max(ts)
-        if t_min - 0.3 > 0.3:
-            cuts.append(t_min - min(clear, t_min - 0.3))
-        if length - t_max - 0.3 > 0.3:
-            cuts.append(t_max + min(clear, length - t_max - 0.3))
-    return cuts, length
-
-
-def _compress(values):
-    """Order-preserving integers: negative values to -1, -2 ..., positive to 1, 2 ..., zero stays zero."""
-    vs = sorted(set(values) | {0})
-    neg = [v for v in vs if v < 0]
-    pos = [v for v in vs if v > 0]
-    m = {0: 0}
-    m.update({v: -(len(neg) - i) for i, v in enumerate(neg)})
-    m.update({v: i + 1 for i, v in enumerate(pos)})
-    return m
-
-
-def compute(db, hops=HOPS, limit=60.0, solver=None):
-    """The drawing order of the roads of the duckOSM db ``db``: a ``Levels``. ``solver``: use OR-Tools (default: if it is installed)."""
-    import time
-
-    import duckdb
-    from shapely import wkb
-    from shapely.ops import substring
-
-    from mapstyle.map import _roads_union
-    t0 = time.time()
-    use = have_solver() if solver is None else solver
-    con = duckdb.connect(str(db), read_only=True)
-    try:
-        union = _roads_union(con, db)
-        roads, lk, pairs = load(con, union)
-        info = {"overpass_pairs": len(pairs), "solver": use, "given_up": 0, "dropped": 0, "cut": 0}
-        if not pairs:
-            info["seconds"] = round(time.time() - t0, 1)
-            return Levels({}, {}, info)
-        seeds = {x for pr in pairs for x in pr}
-        items = _neighbourhood(con, seeds, hops, lk)
-        items.update({r: roads[r] for r in seeds if r in roads})
-        # roads at the edge of the problem touch roads outside it (at 0): they must contain 0
-        nodes = {n for s, t, *_ in items.values() for n in (s, t)}
-        ns = ", ".join(str(n) for n in nodes)
-        outside = set()
-        for e, s, t in con.execute(f"SELECT eid, s, t FROM nl_lv WHERE s IN ({ns}) OR t IN ({ns})").fetchall():
-            if str(e) not in items and str(e) not in lk:
-                outside |= {s, t}
-        boundary = [r for r, (s, t, *_ ) in items.items() if s in outside or t in outside]
-        info.update(roads_in_problem=len(items), boundary=len(boundary))
-        base_h, dropped_h = heuristic(items, pairs)
-        if not use:
-            iv, given = base_h, dropped_h
-            info["given_up"] = len(given)
-            res, cuts, dropped = iv, {}, []
-        else:
-            out0, given, status = solve_penalty(items, pairs, boundary, limit, hint=base_h)
-            if out0 is None:
-                raise RuntimeError(f"node levels: the solver returned {status}")
-            info["status"] = status
-            base, _ = compact(items, pairs, boundary, len(given), limit)
-            base = base or out0
-            res, cuts, dropped = base, {}, []
-            if given:
-                res, cuts, dropped, pairs = _fix_conflicts(con, items, pairs, boundary, base, limit, wkb, substring)
-            info["given_up"] = len(given)
-            info["dropped"], info["cut"] = len(dropped), len(cuts)
-    finally:
-        con.close()
-    # numbers: order-preserving, small
-    vals = [v for ab in res.values() for v in ab] + [v for c in cuts.values() for ab in c["intervals"] for v in ab]
-    cm = _compress(vals)
-    members = defaultdict(list)
-    for e, r in lk.items():
-        members[r].append(e)
-    intervals = {}
-    for r, (a, b) in res.items():
-        a, b = cm[a], cm[b]
-        if r in cuts or (a, b) == (0, 0):
-            continue
-        for e in [r] + members.get(r, []):
-            intervals[e] = (a, b)
-    for r, c in cuts.items():
-        c["intervals"] = [(cm[a], cm[b]) for a, b in c["intervals"]]
-        c["edges"] = [r] + members.get(r, [])
-    info["unsatisfied"] = len(given) if not use else 0              # after the conflict fixes the solver's drawing order is feasible
-    info["levels"] = len({v for ab in intervals.values() for v in ab} | {v for c in cuts.values() for ab in c["intervals"] for v in ab})
-    info["seconds"] = round(time.time() - t0, 1)
-    log.info("node levels: %s", info)
-    return Levels(intervals, cuts, info)
-
-
-def _fix_conflicts(con, items, pairs, boundary, base, limit, wkb, substring):
-    """The conflicts that are left (docs/design/node_levels.md): drop a pair whose crossing is next to an end node; otherwise cut the
-    road that changes level along itself. Every road outside the conflicts keeps its interval in ``base``."""
-    ids = ", ".join(sorted({x for pr in pairs for x in pr}))
-    geom = {str(e): wkb.loads(bytes(g)) for e, g in con.execute(f"SELECT eid, ST_AsWKB(g) FROM nl_lv WHERE eid IN ({ids})").fetchall()}
-    items, pairs = dict(items), list(pairs)
-    dropped, cut, affected, new_node = [], {}, set(), [-1]
-    for rnd in range(5):
-        status, cores, released = solve_hard(items, pairs, boundary, limit)
-        if not cores:
-            break
-        todo = {}
-        for core in cores:
-            affected |= {x.split("#")[0] for pr in core for x in pr}
-            near = [pr for pr in core if _near_node(geom, *pr)]
-            if near:
-                for pr in near:
-                    if pr in pairs:
-                        pairs.remove(pr)
-                        dropped.append(pr)
-                continue
-            lowers = {}
-            for u, l in core:
-                lowers.setdefault(l, []).append(u)
-
-            def vertical(e):
-                ns = set(items[e][:2])
-                return any(abs(items[o][2] - items[e][2]) >= 2 for o in items if o != e and ns & set(items[o][:2]))
-            l = ([x for x in lowers if vertical(x)] or list(lowers))[0]
-            todo.setdefault(l, [])
-            todo[l] += [u for u in lowers[l] if u not in todo[l]]
-        for l, ups in todo.items():
-            root = l.split("#")[0]
-            if root in cut:
-                continue
-            cuts_m, length = _cut_positions(geom[l], ups, geom)
-            if not cuts_m:
-                continue
-            s_, t_, lv, ln = items[l]
-            nodes = [s_] + [new_node.append(new_node[-1] - 1) or new_node[-1] for _ in cuts_m] + [t_]
-            bounds = [0.0] + cuts_m + [length]
-            names = []
-            for i in range(len(bounds) - 1):
-                pid = f"{l}#{i}"
-                geom[pid] = substring(geom[l], bounds[i] / M_PER_DEG, bounds[i + 1] / M_PER_DEG)
-                items[pid] = (nodes[i], nodes[i + 1], lv, bounds[i + 1] - bounds[i])
-                names.append(pid)
-            del items[l]
-            newp = []
-            for u2, x2 in pairs:
-                if x2 == l:
-                    newp += [(u2, pid) for pid in names if geom[u2].crosses(geom[pid])]
-                elif u2 == l:
-                    newp += [(pid, x2) for pid in names if geom[x2].crosses(geom[pid])]
-                else:
-                    newp.append((u2, x2))
-            pairs = sorted(set(newp))
-            cut[l] = {"bounds": bounds, "pieces": names}
-    free = set(affected) | {p for c in cut.values() for p in c["pieces"]}
-    for r in list(free):
-        ns = set(items[r][:2]) if r in items else set()
-        free |= {o for o in items if ns & set(items[o][:2])}
-    fixed = {e: base[e] for e in items if e not in free and e in base}
-    final = solve_fixed(items, pairs, fixed, boundary, limit) or solve_fixed(items, pairs, {}, boundary, limit)
-    if final is None:
-        raise RuntimeError("node levels: no feasible drawing order after the conflict fixes")
-    cuts_out = {r: {"bounds": c["bounds"], "intervals": [final[p] for p in c["pieces"]]} for r, c in cut.items()}
-    res = {e: iv for e, iv in final.items() if "#" not in e}
-    return res, cuts_out, dropped, pairs
-
-
-def with_cuts(roads, levels, scale=2):
-    """The roads GeoDataFrame with ``_cl`` / ``_fl`` (the drawing-order positions, ``scale`` times the interval numbers so that the odd
-    positions between them stay free) and the roads that must be drawn in pieces split: the row of a directed edge of a cut road
-    becomes its first piece (so the row index the planner's graphs point to is unchanged), the other pieces are appended with
-    ``_piece`` set. ``levels``: a ``Levels``."""
-    import geopandas as gpd
-    import pandas as pd
-    from shapely.ops import substring
-
-    roads = roads.copy()
-    iv = levels.intervals
-    roads["_cl"] = [scale * iv.get(e, (0, 0))[0] for e in roads["edge_id"]]
-    roads["_fl"] = [scale * iv.get(e, (0, 0))[1] for e in roads["edge_id"]]
-    roads["_piece"] = False
-    extra = []
-    for rid, c in levels.cuts.items():
-        bounds = c["bounds"]
-        total = bounds[-1]
-        rep = None
-        for e in c["edges"]:
-            idx = roads.index[roads["edge_id"] == e]
-            if len(idx) == 0:
-                continue
-            i = idx[0]
-            g = roads.at[i, "geometry"]
-            if rep is None:
-                rep = g
-            # the piece bounds run along the road's own line; a twin's line runs the other way
-            same = ((g.coords[0][0] - rep.coords[0][0]) ** 2 + (g.coords[0][1] - rep.coords[0][1]) ** 2
-                    <= (g.coords[0][0] - rep.coords[-1][0]) ** 2 + (g.coords[0][1] - rep.coords[-1][1]) ** 2)
-            for n, (a, b) in enumerate(c["intervals"]):
-                lo, hi = (bounds[n], bounds[n + 1]) if same else (total - bounds[n + 1], total - bounds[n])
-                line = substring(g, lo / M_PER_DEG, hi / M_PER_DEG)
-                if n == 0:
-                    roads.at[i, "geometry"], roads.at[i, "_cl"], roads.at[i, "_fl"] = line, scale * a, scale * b
-                else:
-                    r = roads.loc[i].copy()
-                    r["geometry"], r["_cl"], r["_fl"], r["_piece"] = line, scale * a, scale * b, True
-                    if "k" in r.index:
-                        r["k"] = float("nan")
-                    extra.append(r)
-    if extra:
-        roads = gpd.GeoDataFrame(pd.concat([roads, pd.DataFrame(extra)], ignore_index=True), geometry="geometry", crs=roads.crs)
-    return roads