| """Build the per-scenario comparison figure + table for an AWSIM campaign directory, |
| the analogue of the MetaDrive comparison.png. Overlays every agent's real ego path on the |
| shared route and reports on-route distance (how far along the straight route the agent |
| progressed while staying within THRESH metres of it). |
| |
| python make_comparison.py <scenario_dir> # e.g. campaign/scenarioA |
| """ |
| import os, sys, glob, csv |
| import numpy as np |
| import matplotlib |
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
|
|
| THRESH = 5.0 |
|
|
| |
| plt.rcParams.update({ |
| "figure.dpi": 150, "savefig.dpi": 300, |
| "font.size": 13, "axes.titlesize": 15, "axes.labelsize": 13, |
| "legend.fontsize": 10, "xtick.labelsize": 11, "ytick.labelsize": 11, |
| "axes.linewidth": 1.0, "lines.linewidth": 2.6, |
| "font.family": "DejaVu Sans", "pdf.fonttype": 42, "ps.fonttype": 42, |
| }) |
|
|
|
|
| def load_path(d): |
| xs, ys = [], [] |
| f = os.path.join(d, "control.csv") |
| if not os.path.exists(f): |
| return None |
| with open(f) as fh: |
| r = csv.DictReader(fh) |
| for row in r: |
| xs.append(float(row["ego_x"])); ys.append(float(row["ego_y"])) |
| return np.array(list(zip(xs, ys))) if xs else None |
|
|
|
|
| def load_route(d): |
| f = os.path.join(d, "route.csv") |
| pts = [] |
| if os.path.exists(f): |
| with open(f) as fh: |
| r = csv.DictReader(fh) |
| for row in r: |
| pts.append((float(row["x"]), float(row["y"]))) |
| return np.array(pts) if pts else None |
|
|
|
|
| def on_route_distance(path, route): |
| """Max arc length ALONG the route polyline the agent reached while within THRESH m of it. |
| Works for a straight route (AWSIM) and a curving planned route (MetaDrive).""" |
| if path is None or route is None or len(route) < 2 or len(path) < 2: |
| return 0.0 |
| seg = np.diff(route, axis=0) |
| seglen = np.linalg.norm(seg, axis=1) |
| cum = np.concatenate([[0.0], np.cumsum(seglen)]) |
| best = 0.0 |
| for p in path: |
| mind, bests = 1e18, 0.0 |
| for i in range(len(route) - 1): |
| a = route[i]; ab = seg[i]; L2 = float(ab @ ab) |
| t = 0.0 if L2 < 1e-9 else float(np.clip((p - a) @ ab / L2, 0.0, 1.0)) |
| proj = a + t * ab |
| d = float(np.linalg.norm(p - proj)) |
| if d < mind: |
| mind, bests = d, cum[i] + t * seglen[i] |
| if mind < THRESH: |
| best = max(best, bests) |
| return best |
|
|
|
|
| def main(): |
| sdir = sys.argv[1] |
| scen = os.path.basename(sdir.rstrip("/")) |
| agents = sorted(d for d in glob.glob(os.path.join(sdir, "*")) if os.path.isdir(d)) |
| cmap = plt.get_cmap("tab10") |
| fig, ax = plt.subplots(figsize=(7.2, 7.2)) |
| route = None |
| rows = [] |
| allpts = [] |
| order = sorted(range(len(agents)), |
| key=lambda k: -on_route_distance(load_path(agents[k]), load_route(agents[k])) |
| if load_path(agents[k]) is not None else 0) |
| for i in order: |
| d = agents[i]; name = os.path.basename(d) |
| path = load_path(d) |
| if route is None: |
| route = load_route(d) |
| if path is None or len(path) < 2: |
| rows.append((name, 0.0, 0.0)); continue |
| onr = on_route_distance(path, route) |
| plen = float(np.sum(np.linalg.norm(np.diff(path, axis=0), axis=1))) |
| rows.append((name, onr, plen)) |
| allpts.append(path) |
| ax.plot(path[:, 0], path[:, 1], "-", color=cmap(i % 10), solid_capstyle="round", |
| label=f"{name} (on-route {onr:.0f} m, drove {plen:.0f} m)") |
| ax.plot(path[-1, 0], path[-1, 1], "o", color=cmap(i % 10), ms=6, zorder=5) |
| if route is not None: |
| ax.plot(route[:, 0], route[:, 1], "-", color="#c7c7c7", lw=9, alpha=.6, zorder=0, |
| solid_capstyle="round", label="intended route") |
| ax.plot(route[0, 0], route[0, 1], "o", color="black", ms=11, zorder=6, |
| markeredgecolor="white", markeredgewidth=1.0, label="start") |
| if allpts: |
| P = np.vstack(allpts) |
| xmin, xmax = P[:, 0].min(), P[:, 0].max(); ymin, ymax = P[:, 1].min(), P[:, 1].max() |
| mx = max(8.0, 0.12 * max(xmax - xmin, ymax - ymin)) |
| ax.set_xlim(xmin - mx, xmax + mx); ax.set_ylim(ymin - mx, ymax + mx) |
| ax.set_aspect("equal", adjustable="box") |
| ax.grid(True, which="both", color="0.9", lw=0.8, zorder=-1) |
| |
| ax.legend(loc="upper center", bbox_to_anchor=(0.5, -0.22), ncol=2, |
| framealpha=0.97, borderpad=0.6, columnspacing=1.4, handlelength=1.8) |
| _low = sdir.lower() |
| sim = ("MetaDrive (SCS)" if "metadrive" in _low |
| else "AlpaSim (NuRec)" if "alpasim" in _low |
| else "AWSIM (Shinjuku)") |
| sl = scen.lower() |
| letter = "A" if "scenarioa" in sl else ("B" if "scenariob" in sl else scen) |
| seed = "" |
| if "scs3" in sl or "seed3" in sl: |
| seed = " (seed 3)" |
| elif "scs5" in sl or "seed5" in sl: |
| seed = " (seed 5)" |
| scen_nice = f"Scenario {letter}{seed}" if letter in ("A", "B") else scen |
| ax.set_title(f"PCLA agents driving {sim} — {scen_nice}") |
| ax.set_xlabel("x (m from spawn)", labelpad=8); ax.set_ylabel("y (m from spawn)") |
| fig.tight_layout() |
| out = os.path.join(sdir, "comparison.png") |
| fig.savefig(out, bbox_inches="tight") |
| fig.savefig(out.replace(".png", ".pdf"), bbox_inches="tight") |
| print(f"wrote {out} (+ .pdf)") |
| print(f"\n{'agent':<22}{'on-route (m)':>14}{'path len (m)':>14}") |
| for name, onr, plen in sorted(rows, key=lambda r: -r[1]): |
| print(f"{name:<22}{onr:>14.1f}{plen:>14.1f}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
