car/robot/vision/labs/runners/make_a_track_web.py

"""The `trackgen` module of Make a Track (#567): the student's script calls
make() and show(). Runs in the browser (Pyodide) on top of the real
goat_trackgen package, served file by file from the sim tree; the page
(static/js/trackgen.js) registers `goat_track` and draws what show() sends.
No file on the car or in the sim imports this."""

import json
import os
from pathlib import Path

import make_a_track_shims  # noqa: F401  yaml and cKDTree stand-ins, before goat_trackgen
import goat_track  # the page: show(payload)
import goat_track_model as tm  # app/race/track.py: the sim's resampled track model
from goat_trackgen.draw import draw_track_svg
from goat_trackgen.dsl import compile_dsl
from goat_trackgen.geometry_validation import track_geometry_report
from goat_trackgen.wall_repair import build_repaired_track_walls

# what each check means, in the words of the read
ISSUES = {
    "centerline_seam_gap": "the loop does not close: the last segment ends away from the start",
    "seam_tangent_discontinuity": "the loop closes at an angle: the end does not point the way the start does",
    "centerline_self_intersection": "the centerline crosses itself",
    "left_wall_self_intersection": "the outer wall crosses itself",
    "right_wall_self_intersection": "the inner wall crosses itself",
    "wall_cross_intersection": "the two walls cross each other",
    "insufficient_centerline_clearance": "two parts of the track come closer than one width",
    "wall_midpoint_drift": "the walls drift away from the centerline",
    "wall_span_error": "the walls are not one width apart",
    "wall_sample_count_mismatch": "the walls and the centerline have different sample counts",
    "repaired_corridor_invalid": "the walls could not be repaired into a corridor",
}
TRACKS = Path("tracks")
NAME = "Mine"


def make(dsl: str, width: float = 1.2) -> dict:
    """Compile the segments, build the walls, run the geometry checks."""
    track = compile_dsl(
        str(dsl), track_id=NAME, closed=True, width_left_m=width / 2, width_right_m=width / 2
    )
    report = track_geometry_report(track)
    left, right, _ = build_repaired_track_walls(track)
    return {
        "track": track,
        "dsl": str(dsl),
        "width": float(width),
        "report": report,
        "left": left,
        "right": right,
    }


def _csv(path: Path, pts) -> None:
    path.write_text("x_m,y_m\n" + "".join(f"{x:.6f},{y:.6f}\n" for x, y in pts))


def _sim_view(t: dict) -> tuple[dict, dict]:
    """The two JSONs the browser stage takes for a sim track: the polylines
    it draws and the env's resampled model it drives against. The same
    code path as /tracks/<name>/geometry.json and model.json."""
    d = TRACKS / NAME
    d.mkdir(parents=True, exist_ok=True)
    c = t["track"].centerline
    _csv(d / "centerline.csv", c)
    _csv(d / "wall_outer.csv", t["left"])  # the export's convention: CCW left is outer
    _csv(d / "wall_inner.csv", t["right"])
    step = max(1, len(c) // 64)
    _csv(d / "raceline_waypoints.csv", c[::step])
    os.environ["GOATRACER_TRACKS_DIR"] = str(TRACKS)
    tm.geometry.cache_clear()  # both read the files once per name: the name is always Mine
    tm.model.cache_clear()
    return tm.geometry(NAME), tm.model(NAME).to_dict()


def show(t: dict) -> None:
    """Draw the track in the Play card: the generator's own preview, the
    verdict of every check, and, when the loop is valid, the stage."""
    track, report = t["track"], t["report"]
    issues = [str(i) for i in report.get("issues", [])]
    svg = draw_track_svg(track, Path("/tmp/preview.svg"), title=t["dsl"]).read_text()
    c = track.centerline
    length = float(sum(((c[i + 1] - c[i]) ** 2).sum() ** 0.5 for i in range(len(c) - 1)))
    payload = {
        "dsl": t["dsl"],
        "width": t["width"],
        "valid": not issues,
        "issues": [{"key": k, "text": ISSUES.get(k, k)} for k in issues],
        "seam_gap_m": report.get("centerline_seam_gap_m"),
        "length_m": length,
        "segments": [s.segment_class for s in track.segments],
        "svg": svg,
    }
    print(f"{len(track.segments)} segments, {length:.1f} m, {t['width']:.2f} m wide")
    if issues:
        for i in payload["issues"]:
            print(f"  x {i['text']}")
        print("fix the loop, then run again")
    else:
        print("  every check passed: drive it in the Play card")
        payload["geometry"], payload["model"] = _sim_view(t)
    goat_track.show(json.dumps(payload))