#!/usr/bin/env python3 """Regenerate Route-A aggregate XML indexes from standalone route files.""" from __future__ import annotations import argparse import copy import json import math import xml.etree.ElementTree as ET from collections import defaultdict from pathlib import Path FAMILY_DIRS = { "occluded_pedestrian": "occluded_pedestrian", "vehicle_cut_in": "lane_cut_in", "static_obstacle_reveal": "reveal_obstacle", "wrong_way_left_turn": "ghost_driver_left_turn", "wrong_way_right_turn": "ghost_driver_right_turn", "right_turn_on_red_yield": "right_turn_on_red", } def _indent(element: ET.Element, level: int = 0) -> None: prefix = "\n" + level * " " child_prefix = "\n" + (level + 1) * " " children = list(element) if children: if not element.text or not element.text.strip(): element.text = child_prefix for child in children: _indent(child, level + 1) if not child.tail or not child.tail.strip(): child.tail = child_prefix children[-1].tail = prefix elif level and (not element.tail or not element.tail.strip()): element.tail = prefix def _write_routes(path: Path, routes: list[ET.Element]) -> None: root = ET.Element("routes") for route in routes: root.append(copy.deepcopy(route)) _indent(root) path.parent.mkdir(parents=True, exist_ok=True) ET.ElementTree(root).write(path, encoding="utf-8", xml_declaration=True) def _single_route(path: Path) -> ET.Element: routes = ET.parse(path).getroot().findall("route") if len(routes) != 1: raise RuntimeError(f"{path}: expected one route, found {len(routes)}") return routes[0] def _route_length(route: ET.Element) -> float: points = [ tuple(float(node.attrib.get(key, 0.0)) for key in ("x", "y", "z")) for node in route.findall("./waypoints/position") ] return sum( math.hypot(second[0] - first[0], second[1] - first[1]) for first, second in zip(points, points[1:]) ) def _route_progress(route: ET.Element, target: tuple[float, float]) -> float: points = [ tuple(float(node.attrib.get(key, 0.0)) for key in ("x", "y")) for node in route.findall("./waypoints/position") ] best_distance = float("inf") best_progress = 0.0 progress = 0.0 for first, second in zip(points, points[1:]): dx = second[0] - first[0] dy = second[1] - first[1] length = math.hypot(dx, dy) if length <= 1e-9: continue ratio = ( (target[0] - first[0]) * dx + (target[1] - first[1]) * dy ) / (length * length) ratio = min(max(ratio, 0.0), 1.0) px = first[0] + ratio * dx py = first[1] + ratio * dy distance = math.hypot(target[0] - px, target[1] - py) if distance < best_distance: best_distance = distance best_progress = progress + ratio * length progress += length return best_progress def _route_metrics( route: ET.Element, record: dict, reference: ET.Element | None, ) -> tuple[float, float | None]: candidate_length = route.attrib.get("candidate_route_length_m") if candidate_length is None: route_length = _route_length(route) reference_s = None if reference is not None: reference_s = _route_progress( route, ( float(reference.attrib["x"]), float(reference.attrib["y"]), ), ) return route_length, reference_s route_length = float(candidate_length) if not math.isfinite(route_length) or route_length <= 0.0: raise RuntimeError( f"{route.attrib.get('id')}: invalid candidate route length " f"{candidate_length!r}" ) route_s = record.get("route_s") if not isinstance(route_s, dict) or "reference" not in route_s: raise RuntimeError( f"{route.attrib.get('id')}: sparse candidate route is missing " "manifest route_s.reference" ) reference_s = float(route_s["reference"]) if not 0.0 <= reference_s <= route_length: raise RuntimeError( f"{route.attrib.get('id')}: reference progress {reference_s:.3f} " f"is outside candidate route length {route_length:.3f}" ) return route_length, reference_s def sync(root: Path) -> None: manifest_path = root / "manifest.json" manifest = json.loads(manifest_path.read_text(encoding="utf-8")) all_routes = [] by_family: dict[str, list[ET.Element]] = defaultdict(list) by_town: dict[str, list[ET.Element]] = defaultdict(list) for record in manifest["routes"]: family_dir = FAMILY_DIRS[record["family"]] path = root / "routes" / family_dir / f"{record['route_id']}.xml" route = _single_route(path) if route.attrib["id"] != record["route_id"]: raise RuntimeError(f"{path}: route ID differs from manifest") scenario = route.find("./scenarios/scenario") reference = scenario.find("collision_point") if scenario is not None else None route_length, reference_s = _route_metrics(route, record, reference) record["route_length_m"] = round(route_length, 3) if reference_s is not None: recovery_distance = route_length - reference_s if route.attrib.get("candidate_route_length_m") is not None: frozen_recovery = record.get("recovery_distance_m") if frozen_recovery is not None: if abs(float(frozen_recovery) - recovery_distance) > 0.01: raise RuntimeError( f"{record['route_id']}: frozen recovery distance " f"{float(frozen_recovery):.3f} disagrees with " f"candidate geometry ({recovery_distance:.3f})" ) recovery_distance = float(frozen_recovery) record["recovery_distance_m"] = round(recovery_distance, 3) all_routes.append(route) by_family[family_dir].append(route) by_town[route.attrib["town"]].append(route) _write_routes(root / "coopeval_closed.xml", all_routes) for family, routes in sorted(by_family.items()): _write_routes(root / "routes_by_family" / f"{family}.xml", routes) for town, routes in sorted(by_town.items()): _write_routes(root / "routes_by_town" / f"{town}.xml", routes) manifest_path.write_text( json.dumps(manifest, indent=2) + "\n", encoding="utf-8", ) def main() -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( "--root", type=Path, default=Path(__file__).resolve().parents[1], ) args = parser.parse_args() sync(args.root.resolve()) print(f"Synchronized Route-A indexes under {args.root.resolve()}") return 0 if __name__ == "__main__": raise SystemExit(main())