fix(extract): cut_edges() bildet keine Schleifen mehr, Straßen kreuzen das Netz statt es zu überlagern

Fixrunde 1 zu Task 11, zwei von der Koordination gefundene und am echten Netz nachgemessene
Fehler, beide durch die Senkung von MIN_CENTERLINE (15 m) auf MIN_EDGE (5 m) erst möglich:

1. cut_edges() hängte beide Enden eines Schnittstücks über attach() an - dessen 8-m-Umkreis fand
   bei einem Reststück zwischen 5 und 8 m Länge für beide Enden denselben ursprünglichen Knoten
   und machte aus dem geraden Stummel eine Schleife. section.py hält jeden Knoten ab Grad 3 für
   eine Kreuzung; an einem Sackgassenende wären dort Kreuzungsfläche, Zebrastreifen und
   Haltelinie entstanden. Die neue _cut_end() sucht nicht mehr im Umkreis, sondern nur noch nach
   exakter Übereinstimmung mit einem der beiden ursprünglichen Kantenenden.

2. apply_street() hängte die Jefferson Avenue nur mit einem attach()-Paar an ihre beiden Enden.
   Am echten Netz liegt ihr Nordende 23,2 m von jedem Knoten entfernt, aber die Straße kreuzt auf
   dem Weg zu ihrem Südende (6,6 m von Knoten 561) die 11th Street mittendrin, ohne dass dort ein
   Knoten entsteht - zwei Fahrbahnen hätten sich unverbunden überlagert. Die neue insert_edge()
   bricht jede gekreuzte Kante am Kreuzungspunkt auf und teilt sich dort einen Knoten mit der
   neuen Straße (mit attach() für die Knotenwahl, wie gehabt); apply_street() benutzt sie jetzt
   statt des attach()-Paars.

Am echten Netz (1.537 Knoten, 1.790 Kanten vor Flamingo Park) bestätigt: Jefferson Avenue bricht
jetzt korrekt an der 11th Street auf (neuer Knoten, Grad 4) und hängt am Südende weiterhin an
Knoten 561 (Grad 3 -> 4); die Meldezeile und die Sperrflächen-Warnung blieben wörtlich. Die
Schleifenzahl im Gesamtnetz sank von 196 auf 193 (die Park-Anlage schneidet alte Schleifen im
Parkgebiet weg), keine der verbliebenen 193 entstand neu - jede hat ein Vor-Park-Gegenstück im
5-m-Umkreis. Keine Kante unter 1 m, weder vorher noch nachher.

Neue Tests: test_roads_cut.py (Schleifenregression), test_roads_insert.py (drei Szenarien:
Kreuzung in der Mitte, Anhängen an einen Grad-3-Knoten, Kreuzungspunkt nahe einem vorhandenen
Knoten), test_park_street.py (Knotengrad an beiden Kreuzungen der Park-Zufahrtsstraße).

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

tools/extract/leonida/park.py

@@ -17,7 +17,7 @@ from shapely.geometry import LineString, Point, Polygon
 from shapely.ops import unary_union
 
 from .heights import PALM_CLEARANCE, PALM_KERB, palm_points
-from .roads import CLASS_WIDTH, Edge, Graph, attach, cut_edges
+from .roads import CLASS_WIDTH, Graph, cut_edges, insert_edge
 
 
 class ParkError(ValueError):
@@ -497,15 +497,15 @@ def apply_street(world: World, street: Street) -> World:
                 kept.append((piece, bridge))
     roads = kept + [(piece, False) for piece in _polygons(unary_union(joined), MIN_ROAD_AREA)]
 
-    # Die Gasse verschwindet auch aus dem Graphen, und die Jefferson Avenue kommt als Kante
-    # dazu - mit attach() an die Querstraße gehängt, damit dort eine echte Kreuzung entsteht
-    # statt eines freien Endes. Die Klasse folgt der Breite aus der Parkdatei wie bei jeder
+    # Die Gasse verschwindet auch aus dem Graphen, und die Jefferson Avenue kommt als Kante dazu.
+    # insert_edge() statt eines reinen attach()-Paars: Die Avenue endet nicht zwangsläufig an
+    # einer Kreuzung, sie kann eine Querstraße auch mittendrin schneiden (am echten Netz die
+    # 11th Street) - dort muss ein echter Knoten entstehen, sonst läge die neue Fahrbahn nur
+    # unverbunden über der alten. Die Klasse folgt der Breite aus der Parkdatei wie bei jeder
     # anderen Kante auch.
     graph = cut_edges(world.graph, cut)
     klass = min(CLASS_WIDTH, key=lambda name: abs(CLASS_WIDTH[name] - street.width))
-    graph.edges.append(Edge(a=attach(graph, street.start), b=attach(graph, street.end),
-                            points=[tuple(street.start), tuple(street.end)],
-                            width=street.width, klass=klass))
+    graph = insert_edge(graph, [tuple(street.start), tuple(street.end)], street.width, klass)
 
     freed = unary_union(removed + [cut]).difference(corridor)
     covered = [b[0] for b in buildings if b[0].intersects(freed)] + \

tools/extract/leonida/roads.py

@@ -18,7 +18,8 @@ from dataclasses import dataclass, field
 import networkx as nx
 import numpy as np
 from scipy import ndimage as ndi
-from shapely.geometry import LineString, Polygon
+from shapely.geometry import LineString, Point, Polygon
+from shapely.ops import substring
 from skimage.morphology import disk
 
 from .coords import SLICE
@@ -302,11 +303,23 @@ def cut_edges(graph: Graph, cut: Polygon) -> Graph:
             if piece.geom_type != "LineString" or piece.length < MIN_EDGE:
                 continue
             points = [(round(x, 2), round(y, 2)) for x, y in piece.coords]
-            out.edges.append(Edge(a=attach(out, points[0]), b=attach(out, points[-1]),
+            out.edges.append(Edge(a=_cut_end(out, points[0], edge), b=_cut_end(out, points[-1], edge),
                                   points=points, width=edge.width, klass=edge.klass))
     return _renumber(out)
 
 
+def _cut_end(graph: Graph, point: tuple[float, float], edge: Edge) -> int:
+    """Ein Ende eines Schnittstücks: der ursprüngliche Knoten, wenn das Stück dort endet, sonst ein
+    neues Sackgassenende. Nicht attach(): dessen 8-m-Umkreis fände bei einem Reststück unter 8 m für
+    beide Enden denselben Knoten und machte aus dem Stück eine Schleife."""
+    for node in (edge.a, edge.b):
+        px, py = graph.nodes[node].point
+        if abs(px - point[0]) < 0.01 and abs(py - point[1]) < 0.01:
+            return node
+    graph.nodes.append(Node((float(point[0]), float(point[1]))))
+    return len(graph.nodes) - 1
+
+
 def attach(graph: Graph, point: tuple[float, float], radius: float = JUNCTION_RADIUS) -> int:
     """Knoten-ID an dieser Stelle: der nächste innerhalb von radius, sonst ein neuer.
 
@@ -324,6 +337,70 @@ def attach(graph: Graph, point: tuple[float, float], radius: float = JUNCTION_RA
     return len(graph.nodes) - 1
 
 
+# Kürzestes Teilstück, das insert_edge() beim Aufbrechen einer gekreuzten Kante stehen lässt;
+# kürzer wäre praktisch derselbe Punkt und keine Fahrbahn. Dieselbe Grenze wie trimmed_line() in
+# section.py für "die Kante liegt ganz in der Kreuzung".
+INSERT_MIN = 1.0
+
+
+def insert_edge(graph: Graph, points: list[tuple[float, float]], width: float, klass: str) -> Graph:
+    """Eine von Hand ergänzte Straße so ins Netz einfügen, dass sie an ihren Kreuzungen Knoten bildet.
+
+    attach() allein reicht nur, wenn ein Ende der neuen Straße neben einem vorhandenen Knoten
+    liegt. Die Jefferson Avenue lief am echten Netz mittendrin über die 11th Street hinweg, ohne
+    eines ihrer beiden Enden dort zu haben: attach() hätte die neue Fahrbahn einfach über die alte
+    gelegt, ohne dass an der Stelle eine Kreuzungsfläche, ein Eckradius, ein Zebrastreifen oder
+    eine Haltelinie entsteht.
+    """
+    out = Graph(nodes=list(graph.nodes), edges=[])
+    new_line = LineString(points)
+
+    # Jede vorhandene Kante, die die neue Linie kreuzt, an den Kreuzungspunkten aufbrechen.
+    # attach() entscheidet je Punkt, ob dort ein neuer Knoten entsteht oder ein vorhandener in
+    # der Nähe genügt (Regel b) - dieselbe Funktion, die gleich auch die Enden der neuen Straße
+    # anhängt, damit an einer Kreuzung nicht zwei Knoten wenige Meter auseinander liegen.
+    crossings: list[tuple[float, float]] = []
+    for edge in graph.edges:
+        line = LineString(edge.points)
+        found = _crossing_points(new_line, line)
+        if not found:
+            out.edges.append(edge)
+            continue
+        crossings += found
+        stops = sorted({0.0, line.length} | {line.project(Point(p)) for p in found})
+        for start, end in zip(stops, stops[1:]):
+            _add_piece(out, line, start, end, edge.width, edge.klass)
+
+    # Dieselben Kreuzungspunkte (jetzt echte Knoten) plus die beiden Enden der neuen Straße.
+    stops = sorted({0.0, new_line.length} | {new_line.project(Point(p)) for p in crossings})
+    for start, end in zip(stops, stops[1:]):
+        _add_piece(out, new_line, start, end, width, klass)
+    return _renumber(out)
+
+
+def _crossing_points(a: LineString, b: LineString) -> list[tuple[float, float]]:
+    """Die Punkte, an denen sich zwei Linien berühren - deckungsgleiche Teilstücke (kein Punkt,
+    sondern selbst eine Linie) sind ein Datenfehler und werden hier ignoriert, nicht aufgebrochen."""
+    hit = a.intersection(b)
+    if hit.geom_type == "Point":
+        return [(hit.x, hit.y)]
+    if hit.geom_type == "MultiPoint":
+        return [(p.x, p.y) for p in hit.geoms]
+    return []
+
+
+def _add_piece(out: Graph, line: LineString, start: float, end: float, width: float, klass: str) -> None:
+    """Das Teilstück von `line` zwischen zwei Stationen anhängen, wenn es lang genug ist und seine
+    Enden nicht auf denselben Knoten fallen (Regel d) - attach() sucht dafür je Ende in `out`."""
+    if end - start < INSERT_MIN:
+        return
+    points = [(round(x, 2), round(y, 2)) for x, y in substring(line, start, end).coords]
+    a, b = attach(out, points[0]), attach(out, points[-1])
+    if a == b:
+        return
+    out.edges.append(Edge(a=a, b=b, points=points, width=width, klass=klass))
+
+
 def _median_width(line: LineString, distance: np.ndarray) -> float:
     start, end = WIDTH_MARGIN, line.length - WIDTH_MARGIN
     if end <= start: