From 6c73b7f8162d86de4fc5238f85917d37778a778b Mon Sep 17 00:00:00 2001 From: Kenso Grimm Date: Thu, 17 Sep 2026 18:52:56 +0200 Subject: [PATCH] =?UTF-8?q?fix(extract):=20Fahrbahn,=20Restfl=C3=A4chen=20?= =?UTF-8?q?und=20Br=C3=BCcken=20sind=20begehbar,=20nicht=20nur=20der=20Geh?= =?UTF-8?q?weg?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Korrektur eines Fehlers im Plantext, nicht in der vorigen Umsetzung: "begehbar" ist in src/ui/mapMath.js (nearestWalkable()/landingFor()) als "Kollisionsboden ohne Gebäude" definiert, nicht als Fußgängerzone. Fahrbahn ist die kollidierende Mulde, Restflächen liegen auf der Bodenplatte, Brücken haben ihr eigenes Deck - alle drei tragen wie die Landplatte und der Gehweg. Nur Gebäude sperren; Wasser bleibt gesperrt, weil nichts darüber gemalt wird. Ein Klick auf eine Straße oder einen Damm über Wasser landet damit wieder auf ihr, statt ins Nichts zu greifen. chunk["bridges"] wird dafür wieder gelesen und zusätzlich im Kartenbild in BRIDGE gezeichnet, nach der Fahrbahn, damit eine Brücke als Brücke zu sehen ist und nicht als Straße im Wasser. test_walkable_mask_counts_only_ground_with_collision und test_walkable_mask_blocks_buildings_and_water zurückgestellt; ein neuer Test sichert die Brückenfarbe im Kartenbild. test_gehweg_ist_begehbar_die_fahrbahn_nicht sagte nach der Korrektur nicht mehr die Wahrheit über sich selbst - Fahrbahn ist jetzt auch begehbar - und ist umbenannt in test_gehweg_und_fahrbahn_sind_beide_begehbar. Der Skip-Grund von test_committed_map_files_match_the_committed_chunks nennt jetzt die Bedingung fürs Entfernen statt einer Aufgabennummer. Co-Authored-By: Claude Sonnet 5 --- tools/extract/overview.py | 54 +++++++++++--------- tools/extract/tests/test_overview.py | 73 +++++++++++++++++++--------- 2 files changed, 81 insertions(+), 46 deletions(-) diff --git a/tools/extract/overview.py b/tools/extract/overview.py index 0dfb7bf..c9de40d 100644 --- a/tools/extract/overview.py +++ b/tools/extract/overview.py @@ -33,6 +33,7 @@ SIDEWALK = (206, 202, 194) SURFACE = {"sand": (226, 210, 150), "park": (120, 160, 90), "urban": (176, 176, 172), "field": (96, 176, 78), "court": (92, 138, 118), "pool": (70, 150, 220), "parking": ROAD} PATH = (226, 216, 190) +BRIDGE = (196, 92, 92) PALM = (40, 190, 70) OUTLINE = (30, 30, 30) TALL = 120.0 # Meter, ab der ein Gebäude die hellste Färbung bekommt @@ -78,24 +79,25 @@ def _load_chunks(out_dir: Path) -> list[dict]: return [json.loads(f.read_text()) for f in sorted(out_dir.glob("chunk_*.json"))] -def _paint_layers(img, chunks, scale, *, land, surface, sidewalk, lots, road, building, +def _paint_layers(img, chunks, scale, *, land, surface, sidewalk, lots, road, bridge, building, outline=None, palm=None, path=None) -> dict: """Ebene für Ebene über alle Chunks, damit nichts von einem Nachbarchunk überdeckt wird. surface ist eine Funktion der Belagsart, building eine Funktion der Gebäudehöhe; beide können None liefern und die Fläche so aussparen (path=None lässt ebenso die ganze Ebene aus). land, - sidewalk, lots und road sind dagegen an jedem Aufrufort eine feste Füllung — in der - Begehbarkeitsmaske ausdrücklich WALKABLE oder BLOCKED, denn Fahrbahn und Restflächen sollen dort - aktiv sperren statt nur wirkungslos zu bleiben: dort fährt Verkehr, kein Fußgänger soll landen. - Reihenfolge von hinten nach vorn: Land, Beläge, Wege, Gehweg, Restflächen, Fahrbahn, Gebäude — - jede Ebene deckt die vorige ab. + sidewalk, lots, road und bridge sind dagegen an jedem Aufrufort eine feste Füllung: in der + Begehbarkeitsmaske für alle fünf WALKABLE, denn nach der Bedeutung in nearestWalkable() + (src/ui/mapMath.js) ist ein Pixel begehbar, wenn seine Fläche Kollisionsboden ohne Gebäude ist — + und Fahrbahn (die kollidierende Mulde), Restflächen (auf der Bodenplatte) und Brücken (eigenes + Deck) haben Kollision, Beläge und Wege dagegen nicht. + Reihenfolge von hinten nach vorn: Land, Beläge, Wege, Gehweg, Restflächen, Fahrbahn, Brücken, + Gebäude — jede Ebene deckt die vorige ab. Brücken zuletzt, damit eine Brücke als Brücke zu sehen + ist und nicht als Straße im Wasser: ihre Fahrbahn steckt schon in carriageway an derselben Stelle. chunk["markings"] wird hier nie gelesen: bei einem Pixel je Meter wäre eine 10 cm breite Linie - ein Drittel Pixel und damit nur Rauschen. chunk["bridges"] ebenfalls nicht mehr: ihre Fahrbahn - steckt schon in carriageway, ihr begehbarer Streifen im sidewalk — eine eigene Brücken-Regel - braucht es hier nicht mehr. + ein Drittel Pixel und damit nur Rauschen. """ - stats = {"land": 0, "gehweg": 0, "restflaechen": 0, "strassen": 0, "gebaeude": 0, "palmen": 0} + stats = {"land": 0, "gehweg": 0, "restflaechen": 0, "strassen": 0, "bruecken": 0, "gebaeude": 0, "palmen": 0} placed = [(chunk, chunk["origin"][0], -chunk["origin"][1]) for chunk in chunks] for chunk, ox, oy in placed: for rings in chunk["land"]: @@ -122,6 +124,10 @@ def _paint_layers(img, chunks, scale, *, land, surface, sidewalk, lots, road, bu for item in chunk["carriageway"]: _draw(img, item["poly"], ox, oy, road, scale=scale) stats["strassen"] += 1 + for chunk, ox, oy in placed: + for item in chunk["bridges"]: + _draw(img, item["poly"], ox, oy, bridge, scale=scale) + stats["bruecken"] += 1 for chunk, ox, oy in placed: for item in chunk["buildings"]: _draw(img, item["poly"], ox, oy, building(item["height"]), outline=outline, scale=scale) @@ -139,8 +145,8 @@ def render(out_dir: Path, dst: Path) -> dict: size = int((SLICE["x1"] - SLICE["x0"]) * SCALE) img = Image.new("RGB", (size, size), WATER) stats = _paint_layers(img, _load_chunks(out_dir), SCALE, land=LAND, surface=SURFACE.__getitem__, - sidewalk=SIDEWALK, lots=ROAD, road=ROAD, building=_building_shade, - outline=OUTLINE, palm=PALM, path=PATH) + sidewalk=SIDEWALK, lots=ROAD, road=ROAD, bridge=BRIDGE, + building=_building_shade, outline=OUTLINE, palm=PALM, path=PATH) dst.parent.mkdir(parents=True, exist_ok=True) img.save(dst) return stats @@ -149,19 +155,19 @@ def render(out_dir: Path, dst: Path) -> dict: def _walkable_mask(chunks: list[dict], width_m: int) -> Image.Image: """Begehbarkeitsmaske mit WALKABLE_SCALE, vorsichtig aus einem 1-m-Raster verdichtet. - Begehbar heißt: die Figur steht dort auf Kollision. Das tragen nur die Landplatte und der - Gehweg. Fahrbahn und Restflächen sperren aktiv, auch über der Landplatte — dort fährt Verkehr, - kein Fußgänger soll dort landen —, und Gebäude sind geschlossene Kästen. Für eine Brücke gibt es - keine eigene Regel mehr: ihr begehbarer Streifen liegt im Gehweg, der dort die Landplatte - ersetzt, ihre Fahrbahn sperrt wie jede andere. Ein Maskenpixel gilt nur als begehbar, wenn jeder - Quadratmeter darunter frei ist. Ein nur teilweise freier Pixel setzte die Figur sonst in eine - Wand oder vor die Kaimauer ins Wasser; an den ausgelieferten Daten traf das 4,3 % der Klicks - auf Gebäude. Die Landung erfolgt in der Pixelmitte (nearestWalkable in src/ui/mapMath.js), - also mindestens 2 m von jedem gesperrten Quadratmeter entfernt. + Begehbar heißt hier wörtlich, was nearestWalkable() in src/ui/mapMath.js daraus liest: die ganze + Fläche eines Pixels ist Kollisionsboden ohne Gebäude. Das sind Landplatte, Gehweg, Fahrbahn, + Restflächen und Brückendecks — alle fünf tragen für sich, auch eine Brücke über Wasser ganz ohne + Landplatte darunter. Beläge und Wege bleiben reine Auflagen ohne eigene Kollision, Gebäude sind + geschlossene Kästen, und Wasser bleibt gesperrt, weil dort nichts gemalt wird. Ein Maskenpixel + gilt nur als begehbar, wenn jeder Quadratmeter darunter frei ist. Ein nur teilweise freier Pixel + setzte die Figur sonst in eine Wand oder vor die Kaimauer ins Wasser; an den ausgelieferten Daten + traf das 4,3 % der Klicks auf Gebäude. Die Landung erfolgt in der Pixelmitte (nearestWalkable in + src/ui/mapMath.js), also mindestens 2 m von jedem gesperrten Quadratmeter entfernt. """ fine = Image.new("L", (width_m, width_m), BLOCKED) - _paint_layers(fine, chunks, 1.0, land=WALKABLE, surface=lambda _kind: None, - sidewalk=WALKABLE, lots=BLOCKED, road=BLOCKED, building=lambda _height: BLOCKED) + _paint_layers(fine, chunks, 1.0, land=WALKABLE, surface=lambda _kind: None, sidewalk=WALKABLE, + lots=WALKABLE, road=WALKABLE, bridge=WALKABLE, building=lambda _height: BLOCKED) step = round(1 / WALKABLE_SCALE) size = width_m // step cells = np.asarray(fine).reshape(size, step, size, step) @@ -176,7 +182,7 @@ def render_map(out_dir: Path, dst_dir: Path) -> dict: picture = Image.new("RGB", (int(width_m * MAP_SCALE),) * 2, WATER) _paint_layers(picture, chunks, MAP_SCALE, land=LAND, surface=SURFACE.__getitem__, - sidewalk=SIDEWALK, lots=ROAD, road=ROAD, building=_building_shade, + sidewalk=SIDEWALK, lots=ROAD, road=ROAD, bridge=BRIDGE, building=_building_shade, outline=OUTLINE, path=PATH) walkable = _walkable_mask(chunks, width_m) diff --git a/tools/extract/tests/test_overview.py b/tools/extract/tests/test_overview.py index 413bdf7..16e1e59 100644 --- a/tools/extract/tests/test_overview.py +++ b/tools/extract/tests/test_overview.py @@ -58,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.BLOCKED # Fahrbahn bei 110 m / 125 m: sperrt jetzt aktiv, auch auf Land + assert mask.getpixel((27, 31)) == overview.WALKABLE # Fahrbahn bei 110 m / 125 m: kollidierende Mulde, nicht nur Auflage assert mask.getpixel((50, 50)) == overview.WALKABLE # Land bei 200 m / 200 m assert mask.getpixel((375, 375)) == overview.BLOCKED # Wasser @@ -87,10 +87,10 @@ def test_debug_overview_still_draws_palms(tmp_path): def test_walkable_mask_counts_only_ground_with_collision(tmp_path): - """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. + """Begehbar ist aller Boden mit Kollision, ganz ohne Landplatte im Chunk: der Gehweg, die + Fahrbahn als kollidierende Mulde, Restflaechen auf der Bodenplatte und eine Bruecke mit eigenem + Deck tragen alle fuer sich - eine Bruecke ueber Wasser ist deshalb ausdruecklich begehbar. Nur + ein Belag ist reine Auflage ohne eigene Kollision, und natuerlich sperren Gebaeude und Wasser. """ src = tmp_path / "chunks" src.mkdir() @@ -112,12 +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: 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((5, 5)) == overview.BLOCKED # Sand ohne Land bei 20 m / 20 m: reine Auflage, keine Kollision + assert mask.getpixel((27, 5)) == overview.WALKABLE # Fahrbahn ohne Land bei 108 m / 20 m: kollidierende Mulde + assert mask.getpixel((37, 5)) == overview.WALKABLE # Restflaeche ohne Land bei 148 m / 20 m: liegt auf der Bodenplatte 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 + assert mask.getpixel((47, 5)) == overview.WALKABLE # Bruecke ohne Land bei 188 m / 20 m: eigenes Deck, auch ueber Wasser begehbar + assert mask.getpixel((57, 5)) == overview.WALKABLE # Gehweg bei 228 m / 20 m: traegt auch ohne Land def test_walkable_mask_blocks_pixels_that_are_only_partly_free(tmp_path): @@ -144,7 +144,9 @@ 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") +@pytest.mark.skip(reason="public/data/vice-a ist noch im alten Chunk-Format (roads/centerlines); " + "Skip erst entfernen, wenn es im neuen Format (carriageway/sidewalk/lots/" + "bridges/...) neu erzeugt und committet ist") def test_committed_map_files_match_the_committed_chunks(tmp_path): """Kartenbild, Maske und map.json müssen aus genau den ausgelieferten Chunks stammen. @@ -152,13 +154,12 @@ def test_committed_map_files_match_the_committed_chunks(tmp_path): 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. + Übersprungen: render_map() kennt nur noch das neue Chunk-Format (carriageway/sidewalk/lots/ + bridges/...), aber die committeten Chunks unter public/data/vice-a liegen noch im alten Format + (roads/centerlines) — der Pipeline-Lauf, der sie im neuen Format neu erzeugt, ist noch nicht + committet. Bis dahin wirft dieser Test einen KeyError statt eines aussagekräftigen Fehlschlags. + Sobald public/data/vice-a im neuen Chunk-Format neu erzeugt und committet ist, muss dieses Skip + mit entfernt werden. """ shipped = Path(overview.__file__).resolve().parents[2] / "public" / "data" / "vice-a" overview.render_map(shipped, tmp_path) @@ -251,7 +252,11 @@ def test_markierung_wird_nicht_gezeichnet(tmp_path): assert bild.getpixel((105, 120)) == overview.ROAD -def test_gehweg_ist_begehbar_die_fahrbahn_nicht(tmp_path): +def test_gehweg_und_fahrbahn_sind_beide_begehbar(tmp_path): + """Gehweg und Fahrbahn sehen im Kartenbild verschieden aus (SIDEWALK/ROAD), tragen in der + Begehbarkeitsmaske aber beide: 'begehbar' heisst hier Kollisionsboden ohne Gebaeude + (nearestWalkable() in src/ui/mapMath.js), nicht Fussgaengerzone. + """ src = tmp_path / "chunks" src.mkdir() _strassen_fixture(src) @@ -260,7 +265,31 @@ def test_gehweg_ist_begehbar_die_fahrbahn_nicht(tmp_path): 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. + # x=117 statt 113: 4 m Abstand zu jeder Kante des 12 m breiten Gehwegs, genau das Muster der + # Fahrbahnprobe (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" + assert maske.getpixel((105 // step, 10 // step)) == overview.WALKABLE, "Fahrbahn" + + +def test_bruecke_bleibt_im_kartenbild_als_bruecke_sichtbar(tmp_path): + """chunk["bridges"] wird nach der Fahrbahn gezeichnet: sonst zeigte eine Bruecke ueber Wasser nur + ihre Fahrbahn (carriageway liegt an derselben Stelle) und saehe wie eine Strasse im Wasser aus + statt wie eine Bruecke. + """ + src = tmp_path / "chunks" + src.mkdir() + chunk = { + "chunk": [0, 0], + "origin": [SLICE["x0"], -SLICE["y1"]], + "land": [], "surfaces": [], "paths": [], "curb": [], "edges": [], "markings": [], + "sidewalk": [], "lots": [], + "carriageway": [{"poly": [_ring(100, 0, 120, 40)], "klasse": "hauptstrasse"}], + "bridges": [{"poly": [_ring(100, 0, 120, 40)]}], + "buildings": [], "palms": [], + } + (src / "chunk_0_0.json").write_text(json.dumps(chunk)) + (src / "manifest.json").write_text('{"slice": "vice-a"}\n') + dst = tmp_path / "out" + overview.render_map(src, dst) + bild = Image.open(dst / "map.png").convert("RGB") + assert bild.getpixel((110, 20)) == overview.BRIDGE, "Bruecke ueber Wasser, nicht Strasse im Wasser"