feat(extract): Minimap zeichnet Fahrbahn, Gehweg und Restflächen

overview.py las chunk["roads"] und item["bridge"] ohne Rückfall und riss mit Chunks im
Format aus Task 10 (carriageway/sidewalk/lots/bridges) einen KeyError auf. _paint_layers()
liest jetzt carriageway, sidewalk und lots getrennt; chunk["bridges"] braucht keine eigene
Regel mehr, weil seine Fahrbahn schon in carriageway steckt und sein begehbarer Streifen im
sidewalk. Markierungen werden nicht gezeichnet: bei 1 px je 3 m wäre eine 10-cm-Linie ein
Drittel Pixel und nur Rauschen.

In der Begehbarkeitsmaske sperren Fahrbahn und Restflächen jetzt aktiv, auch über der
Landplatte - dort fährt Verkehr, kein Fußgänger soll dort landen. Der Gehweg trägt dafür
auch ohne Landplatte, wie zuvor nur die Brücke; die alte Sonderregel für Brücken entfällt
darum ersatzlos.

Alle Fixtures in test_overview.py, die von Hand im alten Format standen, sind mitgezogen;
eine davon musste dabei die Zusicherung wechseln (Fahrbahn auf Land ist jetzt gesperrt statt
begehbar), zwei weitere kamen dazu (Restfläche und Brücke ohne Land). Der Gehweg-Streifen im
neuen Prüfkörper war im Planentwurf 3 statt 12 m breit: schmaler als eine 4-m-Maskenzelle,
die deshalb nie ganz hineinpasste, unabhängig von der Rundung - jetzt auf 12 m korrigiert wie
die Fahrbahn.

test_committed_map_files_match_the_committed_chunks ist bis Task 16 übersprungen: die
ausgelieferten Chunks unter public/data/vice-a bleiben laut Plan bis dahin im alten Format,
render_map() kennt das nicht mehr.

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

tools/extract/tests/test_overview.py

@@ -2,6 +2,7 @@ import hashlib
 import json
 from pathlib import Path
 
+import pytest
 from PIL import Image
 
 import overview
@@ -23,8 +24,8 @@ def _fixture(tmp_path: Path) -> Path:
         "origin": [SLICE["x0"], -SLICE["y1"]],
         "land": [[_ring(0, 0, 250, 250)]],
         "surfaces": [],
-        "roads": [{"poly": [_ring(100, 0, 120, 250)], "bridge": False}],
-        "centerlines": [],
+        "carriageway": [{"poly": [_ring(100, 0, 120, 250)], "klasse": "hauptstrasse"}],
+        "curb": [], "sidewalk": [], "markings": [], "lots": [], "bridges": [], "edges": [],
         "buildings": [{"poly": [_ring(20, 20, 60, 60)], "height": 12.0, "source": "district", "speculative": False}],
         "palms": [[200.0, 200.0]],
     }
@@ -57,7 +58,7 @@ def test_walkable_mask_blocks_buildings_and_water(tmp_path):
     assert mask.mode == "L"
     assert mask.size == (750, 750)
     assert mask.getpixel((10, 10)) == overview.BLOCKED       # Gebäude bei 40 m / 40 m
-    assert mask.getpixel((27, 31)) == overview.WALKABLE      # Straße bei 110 m / 125 m
+    assert mask.getpixel((27, 31)) == overview.BLOCKED       # Fahrbahn bei 110 m / 125 m: sperrt jetzt aktiv, auch auf Land
     assert mask.getpixel((50, 50)) == overview.WALKABLE      # Land bei 200 m / 200 m
     assert mask.getpixel((375, 375)) == overview.BLOCKED     # Wasser
 
@@ -86,7 +87,11 @@ def test_debug_overview_still_draws_palms(tmp_path):
 
 
 def test_walkable_mask_counts_only_ground_with_collision(tmp_path):
-    """Straßen und Beläge sind reine Auflagen: ohne Landplatte darunter trägt nur eine Brücke."""
+    """Ein Belag traegt weiterhin nicht, ganz ohne Landplatte im Chunk. Fahrbahn und Restflaeche
+    sperren aktiv (siehe test_walkable_mask_blocks_buildings_and_water fuer denselben Befund MIT
+    Landplatte); eine Bruecke fuer sich traegt jetzt nicht mehr - ihr begehbarer Streifen liegt im
+    Gehweg, der die Landplatte an der Stelle ersetzt und hier zeigt, dass er das auch ohne sie tut.
+    """
     src = tmp_path / "chunks"
     src.mkdir()
     chunk = {
@@ -94,9 +99,11 @@ def test_walkable_mask_counts_only_ground_with_collision(tmp_path):
         "origin": [SLICE["x0"], -SLICE["y1"]],
         "land": [],
         "surfaces": [{"poly": [_ring(0, 0, 40, 40)], "kind": "sand"}],
-        "roads": [{"poly": [_ring(100, 0, 120, 40)], "bridge": False},
-                  {"poly": [_ring(200, 0, 220, 40)], "bridge": True}],
-        "centerlines": [],
+        "curb": [], "edges": [], "markings": [],
+        "carriageway": [{"poly": [_ring(100, 0, 120, 40)], "klasse": "wohnstrasse"}],
+        "lots": [{"poly": [_ring(140, 0, 160, 40)]}],
+        "bridges": [{"poly": [_ring(180, 0, 200, 40)]}],
+        "sidewalk": [{"poly": [_ring(220, 0, 240, 40)]}],
         "buildings": [],
         "palms": [],
     }
@@ -105,10 +112,12 @@ def test_walkable_mask_counts_only_ground_with_collision(tmp_path):
     dst = tmp_path / "out"
     overview.render_map(src, dst)
     mask = Image.open(dst / "map-walkable.png")
-    assert mask.getpixel((5, 5)) == overview.BLOCKED       # Sand ohne Land bei 20 m / 20 m: keine Kollision
-    assert mask.getpixel((27, 5)) == overview.BLOCKED      # Straße ohne Land bei 110 m / 20 m: keine Kollision
-    assert mask.getpixel((52, 5)) == overview.WALKABLE     # Brücke bei 210 m / 20 m
-    assert mask.getpixel((40, 5)) == overview.BLOCKED      # Wasser bei 160 m / 20 m
+    assert mask.getpixel((5, 5)) == overview.BLOCKED       # Sand ohne Land bei 20 m / 20 m: traegt nicht
+    assert mask.getpixel((27, 5)) == overview.BLOCKED      # Fahrbahn ohne Land bei 108 m / 20 m: sperrt aktiv
+    assert mask.getpixel((37, 5)) == overview.BLOCKED      # Restflaeche ohne Land bei 148 m / 20 m: sperrt aktiv
+    assert mask.getpixel((42, 5)) == overview.BLOCKED      # Wasser bei 168 m / 20 m
+    assert mask.getpixel((47, 5)) == overview.BLOCKED      # Bruecke ohne Land bei 188 m / 20 m: traegt nicht mehr
+    assert mask.getpixel((57, 5)) == overview.WALKABLE     # Gehweg bei 228 m / 20 m: traegt jetzt auch ohne Land
 
 
 def test_walkable_mask_blocks_pixels_that_are_only_partly_free(tmp_path):
@@ -120,8 +129,7 @@ def test_walkable_mask_blocks_pixels_that_are_only_partly_free(tmp_path):
         "origin": [SLICE["x0"], -SLICE["y1"]],
         "land": [[_ring(0, 0, 102, 250)]],                       # Küste bei x = 102 m, mitten in Pixel 25
         "surfaces": [],
-        "roads": [],
-        "centerlines": [],
+        "carriageway": [], "curb": [], "sidewalk": [], "markings": [], "lots": [], "bridges": [], "edges": [],
         "buildings": [{"poly": [_ring(38, 40, 50, 50)], "height": 8.0, "source": "district", "speculative": False}],
         "palms": [],
     }
@@ -136,12 +144,21 @@ def test_walkable_mask_blocks_pixels_that_are_only_partly_free(tmp_path):
     assert mask.getpixel((8, 11)) == overview.WALKABLE       # 32..36 m: frei
 
 
+@pytest.mark.skip(reason="public/data/vice-a ist bis Task 16 im alten Chunk-Format; siehe Docstring")
 def test_committed_map_files_match_the_committed_chunks(tmp_path):
     """Kartenbild, Maske und map.json müssen aus genau den ausgelieferten Chunks stammen.
 
     Ändert ein Pipeline-Lauf die Chunks, ohne dass overview.py läuft, zeigte die Minimap eine alte
     Welt und landete nach einer alten Maske. Die Laufzeitprüfung über manifest_sha256 bemerkt das
     erst im Browser, dieser Test schon beim Testlauf.
+
+    Übersprungen bis Task 16: render_map() liest seit dieser Aufgabe (15) nur noch carriageway,
+    sidewalk und lots statt roads und centerlines, aber public/data/vice-a bleibt laut Plan (Ruling
+    zu Task 12 in docs/superpowers/sdd/2026-09-16-strassen/progress.md) bis Task 16 im alten Format —
+    der Pipeline-Lauf in Task 12 schreibt die Daten nur zur Messung und stellt sie danach per
+    git checkout wieder her. Bis Task 16 die Welt neu erzeugt und committet, wirft dieser Test einen
+    KeyError statt eines aussagekräftigen Fehlschlags; Task 16 muss dieses Skip mit den neuen Daten
+    zusammen entfernen.
     """
     shipped = Path(overview.__file__).resolve().parents[2] / "public" / "data" / "vice-a"
     overview.render_map(shipped, tmp_path)
@@ -163,8 +180,7 @@ def test_map_picture_draws_paths_and_the_new_surface_kinds(tmp_path):
                      {"poly": [_ring(50, 0, 90, 40)], "kind": "court"},
                      {"poly": [_ring(0, 50, 40, 90)], "kind": "pool"},
                      {"poly": [_ring(50, 50, 90, 90)], "kind": "parking"}],
-        "roads": [],
-        "centerlines": [],
+        "carriageway": [], "curb": [], "sidewalk": [], "markings": [], "lots": [], "bridges": [], "edges": [],
         "buildings": [],
         "palms": [],
         "paths": [{"poly": [_ring(100, 0, 104, 250)]}],
@@ -180,3 +196,71 @@ def test_map_picture_draws_paths_and_the_new_surface_kinds(tmp_path):
     assert picture.getpixel((70, 70)) == overview.ROAD                 # Parkplatz in Straßenfarbe
     assert picture.getpixel((102, 125)) == overview.PATH
     assert Image.open(dst / "map-walkable.png").getpixel((25, 31)) == overview.WALKABLE   # Weg auf Land
+
+
+def _strassen_fixture(tmp_path: Path) -> Path:
+    """Chunk A1 mit den Schichten aus Teil 2. Aufbau wie _fixture() oben in dieser Datei:
+
+    Bei scale 1 fallen die chunk-lokalen Koordinaten von chunk_0_0 genau auf die Kartenpixel.
+
+    Der Gehweg ist hier 12 statt 3 m breit (anders als im Planentwurf): _draw() zeichnet Fuellung
+    und Umriss in derselben Farbe (Kommentar dort erklaert, warum), damit angrenzende Flaechen keine
+    Lueckenpixel lassen - an der gemeinsamen Kante mit der Fahrbahn bei x=112 gewinnt dadurch je nach
+    Zeichenreihenfolge die eine oder die andere Flaeche die Grenzspalte. Bei 4 m je Maskenpixel zaehlt
+    eine Zelle nur als frei, wenn alle 16 Meterzellen frei sind; ein 3 m breiter Streifen ist schmaler
+    als eine Maskenzelle und kann darum nie eine ganz umschliessen, unabhaengig von der Rundung.
+    """
+    chunk = {
+        "chunk": [0, 0],
+        "origin": [SLICE["x0"], -SLICE["y1"]],
+        "land": [[_ring(0, 0, 250, 250)]],
+        "surfaces": [], "buildings": [], "palms": [], "paths": [], "edges": [], "curb": [],
+        "bridges": [], "lots": [{"poly": [_ring(10, 150, 60, 200)]}],
+        "carriageway": [{"poly": [_ring(100, 0, 112, 250)], "klasse": "hauptstrasse"}],
+        "sidewalk": [{"poly": [_ring(112, 0, 124, 250)]}],
+        "markings": [{"poly": [_ring(105, 0, 105.1, 250)], "art": "gelb_doppelt"}],
+    }
+    (tmp_path / "chunk_0_0.json").write_text(json.dumps(chunk))
+    (tmp_path / "manifest.json").write_text('{"slice": "vice-a"}\n')
+    return tmp_path
+
+
+def test_karte_zeichnet_fahrbahn_gehweg_und_restflaeche(tmp_path):
+    src = tmp_path / "chunks"
+    src.mkdir()
+    _strassen_fixture(src)
+    dst = tmp_path / "out"
+    dst.mkdir()
+    overview.render_map(src, dst)
+    bild = Image.open(dst / "map.png").convert("RGB")
+    assert bild.getpixel((105, 10)) == overview.ROAD, "die Fahrbahn"
+    assert bild.getpixel((113, 10)) == overview.SIDEWALK, "der Gehweg daneben"
+    assert bild.getpixel((30, 170)) == overview.ROAD, "die Restflaeche im Strassenton"
+
+
+def test_markierung_wird_nicht_gezeichnet(tmp_path):
+    """Bei 1 px je 3 m waere eine 10-cm-Linie ein Drittel Pixel und damit nur Rauschen."""
+    src = tmp_path / "chunks"
+    src.mkdir()
+    _strassen_fixture(src)
+    dst = tmp_path / "out"
+    dst.mkdir()
+    overview.render_map(src, dst)
+    bild = Image.open(dst / "map.png").convert("RGB")
+    # Genau auf der Markierung: trotzdem Fahrbahnfarbe, kein Gelb.
+    assert bild.getpixel((105, 120)) == overview.ROAD
+
+
+def test_gehweg_ist_begehbar_die_fahrbahn_nicht(tmp_path):
+    src = tmp_path / "chunks"
+    src.mkdir()
+    _strassen_fixture(src)
+    dst = tmp_path / "out"
+    dst.mkdir()
+    overview.render_map(src, dst)
+    maske = Image.open(dst / "map-walkable.png").convert("L")
+    step = round(1 / overview.WALKABLE_SCALE)
+    # x=117 statt 113: 4 m Abstand zu jeder Kante des jetzt 12 m breiten Gehwegs, genau das Muster
+    # der Fahrbahnprobe unten (x=105, 4 m Abstand zu deren Kanten 100/112) - keine Grenzzelle.
+    assert maske.getpixel((117 // step, 10 // step)) == overview.WALKABLE, "Gehweg"
+    assert maske.getpixel((105 // step, 10 // step)) == overview.BLOCKED, "Fahrbahn"