feat(extract): Bordstein an jeder Straße, auch an der Gasse

Der Bordstein ist keine Ausstattung wie ein Gehweg, sondern die Kante, an
der der Asphalt endet — und die hat auch eine Hinterhofgasse. _kerb_lines()
schneidet darum nur noch die Brücken aus dem Fahrbahnrand: Dort steckt die
Fahrbahn im Deck, eine Kante stünde in der Luft. Gehweg und Markierung
bleiben der Gasse weiterhin fern.

Das Feld kerb im Querschnitt entfällt. Es steuerte zuletzt nur noch Gehweg
und Markierung und war aus walk > 0 ableitbar; kerb_only heißt deshalb
jetzt walk_only.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tools/extract/leonida/marking.py

@@ -119,7 +119,7 @@ def junction_marks(graph: Graph, node: int) -> list[tuple[Polygon, str]]:
     blank.
     """
     incident = graph.incident(node)
-    echte = [k for k in incident if SECTION[graph.edges[k].klass].kerb]
+    echte = [k for k in incident if SECTION[graph.edges[k].klass].walk]
     if len(echte) < 2:
         return []
     reach = setback(graph, node)

tools/extract/leonida/section.py

@@ -31,15 +31,14 @@ class Section:
     walk: float
     lanes: int
     parking: float
-    kerb: bool
 
 
 SECTION = {
     # Hinterhofgasse: eine Fahrgasse, kein Bordstein, kein Gehweg, keine Markierung.
-    "gasse":        Section(corridor=6.0,  carriageway=6.0,  walk=0.0, lanes=1, parking=0.0, kerb=False),
-    "wohnstrasse":  Section(corridor=12.0, carriageway=7.0,  walk=2.5, lanes=2, parking=0.0, kerb=True),
-    "hauptstrasse": Section(corridor=18.0, carriageway=12.0, walk=3.0, lanes=2, parking=2.5, kerb=True),
-    "boulevard":    Section(corridor=24.0, carriageway=18.0, walk=3.0, lanes=4, parking=2.0, kerb=True),
+    "gasse":        Section(corridor=6.0,  carriageway=6.0,  walk=0.0, lanes=1, parking=0.0),
+    "wohnstrasse":  Section(corridor=12.0, carriageway=7.0,  walk=2.5, lanes=2, parking=0.0),
+    "hauptstrasse": Section(corridor=18.0, carriageway=12.0, walk=3.0, lanes=2, parking=2.5),
+    "boulevard":    Section(corridor=24.0, carriageway=18.0, walk=3.0, lanes=4, parking=2.0),
 }
 assert all(s.carriageway + 2 * s.walk == s.corridor == CLASS_WIDTH[n] for n, s in SECTION.items())
 
@@ -78,18 +77,18 @@ def ribbon(graph: Graph, k: int):
 FILLET = 6.0
 
 
-def junction_arms(graph: Graph, node: int, kerb_only: bool = False) -> list:
+def junction_arms(graph: Graph, node: int, walk_only: bool = False) -> list:
     """Die Armstummel einer Kreuzung, je auf ihre eigene Fahrbahnbreite gepuffert.
 
     Zweimal gebraucht (Fixrunde 5 zu Task 7): junction_area() vereinigt alle und rundet die
-    einspringenden Ecken; die Gehwegquelle in street.py nimmt nur die Arme mit Bordstein, ohne
+    einspringenden Ecken; die Gehwegquelle in street.py nimmt nur die Arme mit Gehweg, ohne
     Rundung. Deshalb hier einmal, statt die Stummelbildung zu wiederholen.
     """
     reach = setback(graph, node)
     arme = []
     for k in graph.incident(node):
         edge = graph.edges[k]
-        if len(edge.points) < 2 or (kerb_only and not SECTION[edge.klass].kerb):
+        if len(edge.points) < 2 or (walk_only and not SECTION[edge.klass].walk):
             continue          # Punktkanten haben keine Richtung; LineString wirft an ihnen
         # Eine Schleife hängt mit beiden Enden am selben Knoten und braucht deshalb zwei Stummel.
         # incident() liefert sie nur einmal, und edge.a == node ist bei ihr immer wahr — ohne den
@@ -104,23 +103,23 @@ def junction_arms(graph: Graph, node: int, kerb_only: bool = False) -> list:
     return arme
 
 
-def junction_area(graph: Graph, node: int, kerb_only: bool = False):
+def junction_area(graph: Graph, node: int, walk_only: bool = False):
     """Die Fläche einer Kreuzung: die Stummel aller Arme, mit gerundeten einspringenden Ecken.
 
     Gerundet wird durch Schließen (aufblasen, dann wieder schrumpfen) - und ausdrücklich nur
     innerhalb einer Scheibe um den Knoten. Auf das ganze Netz angewandt verklebte dieselbe
     Operation zwei parallele Straßen, deren Fahrbahnen weniger als 2 * FILLET auseinanderliegen.
 
-    kerb_only rundet nur den Kreuzungsanteil der bordsteintragenden Arme (Befund 7 der Fixwelle,
+    walk_only rundet nur den Kreuzungsanteil der Arme mit Gehweg (Befund 7 der Fixwelle,
     für die Gehwegquelle in street.py): Eine Gasse liefert dabei gar keinen Arm in die zu
     schließende Fläche, kann also auch keine Nische mit einem Nachbararm bilden - anders als
     Fixrunde 4, die dieselbe Rundung auf ALLE Arme anwandte und damit Gassen mit rundete.
     """
     incident = graph.incident(node)
-    if not incident or (kerb_only and not any(SECTION[graph.edges[k].klass].kerb for k in incident)):
+    if not incident or (walk_only and not any(SECTION[graph.edges[k].klass].walk for k in incident)):
         return None
     reach = setback(graph, node)
-    star = unary_union(junction_arms(graph, node, kerb_only=kerb_only))
+    star = unary_union(junction_arms(graph, node, walk_only=walk_only))
     near = Point(graph.nodes[node].point).buffer(reach + FILLET + 2.0)
     rounded = star.buffer(FILLET, join_style="round").buffer(-FILLET, join_style="round")
     return star.union(rounded.intersection(near))

tools/extract/leonida/street.py

@@ -38,7 +38,7 @@ def build_street(graph: Graph, corridor, bridges) -> Street:
     sidewalk = _sidewalk(_walk_source(graph), carriage, corridor)
     return Street(
         carriageway=carriage,
-        kerb=_kerb_lines(carriage, _kerbless_zone(graph, 0.2), bridges),
+        kerb=_kerb_lines(carriage, bridges),
         sidewalk=sidewalk,
         lots=_lots(carriage, corridor, sidewalk),
     )
@@ -53,44 +53,24 @@ def _walk_source(graph: Graph):
     in Fixrunde 4 zu viel Gasse mit, weil sie die einspringende Ecke zwischen zwei benachbarten
     Gassenstummeln zu einer Nische auffüllte. Der eigentliche Fehler war aber, Gassenarme
     überhaupt in die zu rundende Fläche aufzunehmen - nicht die Rundung selbst. Ohne sie blieb
-    stattdessen an jeder gewöhnlichen Kreuzung (mehrere Arme mit Bordstein, keine Gasse
+    stattdessen an jeder gewöhnlichen Kreuzung (mehrere Arme mit Gehweg, keine Gasse
     beteiligt) eine Lücke zwischen der ungerundeten Gehwegquelle und der gerundeten Fahrbahn:
     0,26-2,2 m² je Ecke bei 690 Kreuzungen, weil `carriage` (carriageway_area(), gerundet mit
     FILLET=6) und `walk_source` (ungerundet) an der Kreuzungsecke verschieden geformt waren und
     eine reine Dilatation um WALK_MAX=3 eine Reflexecke nicht nachzeichnet.
 
-    junction_area(kerb_only=True) rundet jetzt nur den Kreuzungsanteil der bordsteintragenden
+    junction_area(walk_only=True) rundet jetzt nur den Kreuzungsanteil der bordsteintragenden
     Arme: Eine Gasse liefert dabei keinen Arm in die zu schließende Fläche und kann deshalb auch
     keine Nische mit einem Nachbararm bilden, gewöhnliche Kreuzungsecken bekommen aber dieselbe
     Rundung wie die Fahrbahn und schließen die Lücke.
     """
     teile = [band for k, edge in enumerate(graph.edges)
-             if SECTION[edge.klass].kerb and (band := ribbon(graph, k)) is not None]
+             if SECTION[edge.klass].walk and (band := ribbon(graph, k)) is not None]
     teile += [area for node in range(len(graph.nodes)) if graph.degree(node) >= 3
-              and (area := junction_area(graph, node, kerb_only=True)) is not None and not area.is_empty]
+              and (area := junction_area(graph, node, walk_only=True)) is not None and not area.is_empty]
     return unary_union(teile) if teile else None
 
 
-def _kerbless_zone(graph: Graph, extra: float):
-    """Der Korridor aller Klassen ohne Bordstein, aus den vollen Mittellinien, um `extra` über die
-    halbe Fahrbahnbreite hinaus gepuffert.
-
-    Nur noch einmal gebraucht: Der Bordstein hört hier auf (_kerb_lines()) - eine Gasse hat laut
-    SECTION weder Bordstein noch Gehweg, und die Fuge dafür ist 0,2 m über die eigene
-    Fahrbahnbreite hinaus.
-
-    Bis Fixrunde 4 schnitt dieselbe Zone auch den Kreuzungsanteil der Gehwegquelle zu; seit
-    Fixrunde 5 nimmt _walk_source() stattdessen von vornherein nur die Arme mit Bordstein
-    (junction_area(kerb_only=True), Befund 7 der Fixwelle) und braucht deshalb keinen
-    nachträglichen Abzug mehr.
-    """
-    zonen = [LineString(edge.points).buffer(SECTION[edge.klass].carriageway / 2 + extra,
-                                            cap_style="flat", join_style="mitre", mitre_limit=1.5)
-             for edge in graph.edges
-             if not SECTION[edge.klass].kerb and len(edge.points) >= 2]
-    return unary_union(zonen) if zonen else None
-
-
 def _sidewalk(walk_source, carriage, corridor):
     """Der Streifen zwischen Fahrbahnkante und Korridorrand.
 
@@ -114,10 +94,17 @@ def _sidewalk(walk_source, carriage, corridor):
     return to_multipolygon(result)
 
 
-def _kerb_lines(carriage, kerbless, bridges) -> list[LineString]:
-    """Die Fahrbahnkante, ohne die Stücke an Gassen und auf Brücken."""
-    ohne = [] if kerbless is None else [kerbless]
-    ohne += [b.buffer(0.2) for b in bridges]
+def _kerb_lines(carriage, bridges) -> list[LineString]:
+    """Die ganze Fahrbahnkante, nur ohne die Stücke auf Brücken.
+
+    Bis zur Nutzerentscheidung vom 18.09.2026 blieben auch die Gassen frei: Der Entwurf sah für sie
+    weder Bordstein noch Gehweg noch Markierung vor (Hinterhofgassen in Miami Beach). Der Bordstein
+    gehört jetzt an jede Straße - wo Asphalt an Land grenzt, endet er mit einer Kante. Gehweg und
+    Markierung bleiben der Gasse weiterhin fern, das ändert die Entscheidung nicht.
+
+    Brücken bleiben ausgenommen: Dort steckt die Fahrbahn im Deck, eine Kante stünde in der Luft.
+    """
+    ohne = [b.buffer(0.2) for b in bridges]
     rand = carriage.boundary
     if ohne:
         rand = rand.difference(unary_union(ohne))