Add files using upload-large-folder tool

data/generated/city_0002/scenarios/accident/config.json

@@ -1,13 +1,13 @@
-{
-  "interval": 1.0,
-  "seed": 11348,
-  "dir": "/root/aditya/agentic-traffic/data/generated/city_0002/",
-  "roadnetFile": "roadnet.json",
-  "flowFile": "scenarios/accident/flow.json",
-  "rlTrafficLight": true,
-  "laneChange": false,
-  "saveReplay": false,
-  "roadnetLogFile": "scenarios/accident/roadnetLogFile.json",
-  "replayLogFile": "scenarios/accident/replay.txt",
-  "step": 3600
-}
+{
+  "interval": 1.0,
+  "seed": 11348,
+  "dir": "C:/Users/toke/Desktop/agentic-traffic/data/generated/city_0002/",
+  "roadnetFile": "roadnet.json",
+  "flowFile": "scenarios/accident/flow.json",
+  "rlTrafficLight": true,
+  "laneChange": false,
+  "saveReplay": false,
+  "roadnetLogFile": "scenarios/accident/roadnetLogFile.json",
+  "replayLogFile": "scenarios/accident/replay.txt",
+  "step": 3600
+}

data/generated/city_0002/scenarios/construction/config.json

@@ -1,13 +1,13 @@
-{
-  "interval": 1.0,
-  "seed": 11449,
-  "dir": "/root/aditya/agentic-traffic/data/generated/city_0002/",
-  "roadnetFile": "roadnet.json",
-  "flowFile": "scenarios/construction/flow.json",
-  "rlTrafficLight": true,
-  "laneChange": false,
-  "saveReplay": false,
-  "roadnetLogFile": "scenarios/construction/roadnetLogFile.json",
-  "replayLogFile": "scenarios/construction/replay.txt",
-  "step": 3600
-}
+{
+  "interval": 1.0,
+  "seed": 11449,
+  "dir": "C:/Users/toke/Desktop/agentic-traffic/data/generated/city_0002/",
+  "roadnetFile": "roadnet.json",
+  "flowFile": "scenarios/construction/flow.json",
+  "rlTrafficLight": true,
+  "laneChange": false,
+  "saveReplay": false,
+  "roadnetLogFile": "scenarios/construction/roadnetLogFile.json",
+  "replayLogFile": "scenarios/construction/replay.txt",
+  "step": 3600
+}

data/generated/city_0002/scenarios/district_overload/config.json

@@ -1,13 +1,13 @@
-{
-  "interval": 1.0,
-  "seed": 11651,
-  "dir": "/root/aditya/agentic-traffic/data/generated/city_0002/",
-  "roadnetFile": "roadnet.json",
-  "flowFile": "scenarios/district_overload/flow.json",
-  "rlTrafficLight": true,
-  "laneChange": false,
-  "saveReplay": false,
-  "roadnetLogFile": "scenarios/district_overload/roadnetLogFile.json",
-  "replayLogFile": "scenarios/district_overload/replay.txt",
-  "step": 3600
-}
+{
+  "interval": 1.0,
+  "seed": 11651,
+  "dir": "C:/Users/toke/Desktop/agentic-traffic/data/generated/city_0002/",
+  "roadnetFile": "roadnet.json",
+  "flowFile": "scenarios/district_overload/flow.json",
+  "rlTrafficLight": true,
+  "laneChange": false,
+  "saveReplay": false,
+  "roadnetLogFile": "scenarios/district_overload/roadnetLogFile.json",
+  "replayLogFile": "scenarios/district_overload/replay.txt",
+  "step": 3600
+}

data/generated/city_0002/scenarios/evening_rush/config.json

@@ -1,13 +1,13 @@
-{
-  "interval": 1.0,
-  "seed": 11247,
-  "dir": "/root/aditya/agentic-traffic/data/generated/city_0002/",
-  "roadnetFile": "roadnet.json",
-  "flowFile": "scenarios/evening_rush/flow.json",
-  "rlTrafficLight": true,
-  "laneChange": false,
-  "saveReplay": false,
-  "roadnetLogFile": "scenarios/evening_rush/roadnetLogFile.json",
-  "replayLogFile": "scenarios/evening_rush/replay.txt",
-  "step": 3600
-}
+{
+  "interval": 1.0,
+  "seed": 11247,
+  "dir": "C:/Users/toke/Desktop/agentic-traffic/data/generated/city_0002/",
+  "roadnetFile": "roadnet.json",
+  "flowFile": "scenarios/evening_rush/flow.json",
+  "rlTrafficLight": true,
+  "laneChange": false,
+  "saveReplay": false,
+  "roadnetLogFile": "scenarios/evening_rush/roadnetLogFile.json",
+  "replayLogFile": "scenarios/evening_rush/replay.txt",
+  "step": 3600
+}

data/generated/city_0002/scenarios/event_spike/config.json

@@ -1,13 +1,13 @@
-{
-  "interval": 1.0,
-  "seed": 11550,
-  "dir": "/root/aditya/agentic-traffic/data/generated/city_0002/",
-  "roadnetFile": "roadnet.json",
-  "flowFile": "scenarios/event_spike/flow.json",
-  "rlTrafficLight": true,
-  "laneChange": false,
-  "saveReplay": false,
-  "roadnetLogFile": "scenarios/event_spike/roadnetLogFile.json",
-  "replayLogFile": "scenarios/event_spike/replay.txt",
-  "step": 3600
-}
+{
+  "interval": 1.0,
+  "seed": 11550,
+  "dir": "C:/Users/toke/Desktop/agentic-traffic/data/generated/city_0002/",
+  "roadnetFile": "roadnet.json",
+  "flowFile": "scenarios/event_spike/flow.json",
+  "rlTrafficLight": true,
+  "laneChange": false,
+  "saveReplay": false,
+  "roadnetLogFile": "scenarios/event_spike/roadnetLogFile.json",
+  "replayLogFile": "scenarios/event_spike/replay.txt",
+  "step": 3600
+}

data/generated/city_0002/scenarios/morning_rush/config.json

@@ -1,13 +1,13 @@
-{
-  "interval": 1.0,
-  "seed": 11146,
-  "dir": "/root/aditya/agentic-traffic/data/generated/city_0002/",
-  "roadnetFile": "roadnet.json",
-  "flowFile": "scenarios/morning_rush/flow.json",
-  "rlTrafficLight": true,
-  "laneChange": false,
-  "saveReplay": false,
-  "roadnetLogFile": "scenarios/morning_rush/roadnetLogFile.json",
-  "replayLogFile": "scenarios/morning_rush/replay.txt",
-  "step": 3600
-}
+{
+  "interval": 1.0,
+  "seed": 11146,
+  "dir": "C:/Users/toke/Desktop/agentic-traffic/data/generated/city_0002/",
+  "roadnetFile": "roadnet.json",
+  "flowFile": "scenarios/morning_rush/flow.json",
+  "rlTrafficLight": true,
+  "laneChange": false,
+  "saveReplay": false,
+  "roadnetLogFile": "scenarios/morning_rush/roadnetLogFile.json",
+  "replayLogFile": "scenarios/morning_rush/replay.txt",
+  "step": 3600
+}

data/generated/city_0002/scenarios/normal/config.json

@@ -1,13 +1,13 @@
-{
-  "interval": 1.0,
-  "seed": 11045,
-  "dir": "/root/aditya/agentic-traffic/data/generated/city_0002/",
-  "roadnetFile": "roadnet.json",
-  "flowFile": "scenarios/normal/flow.json",
-  "rlTrafficLight": true,
-  "laneChange": false,
-  "saveReplay": false,
-  "roadnetLogFile": "scenarios/normal/roadnetLogFile.json",
-  "replayLogFile": "scenarios/normal/replay.txt",
-  "step": 3600
-}
+{
+  "interval": 1.0,
+  "seed": 11045,
+  "dir": "C:/Users/toke/Desktop/agentic-traffic/data/generated/city_0002/",
+  "roadnetFile": "roadnet.json",
+  "flowFile": "scenarios/normal/flow.json",
+  "rlTrafficLight": true,
+  "laneChange": false,
+  "saveReplay": false,
+  "roadnetLogFile": "scenarios/normal/roadnetLogFile.json",
+  "replayLogFile": "scenarios/normal/replay.txt",
+  "step": 3600
+}

data/splits/splits/README.md

@@ -0,0 +1,21 @@
+# data/splits
+
+City-level train/validation/test splits for the generated dataset.
+
+## Files
+
+- [train_cities.txt](/Users/aditya/Developer/traffic-llm/data/splits/train_cities.txt)
+- [val_cities.txt](/Users/aditya/Developer/traffic-llm/data/splits/val_cities.txt)
+- [test_cities.txt](/Users/aditya/Developer/traffic-llm/data/splits/test_cities.txt)
+
+## Important rule
+
+Splits are by city only. All scenarios for a given city belong to the same split.
+
+## Regeneration
+
+Use:
+
+`python3 -m training.train_local_policy make-splits`
+
+The split logic is implemented in [training/dataset.py](/Users/aditya/Developer/traffic-llm/training/dataset.py).

data/splits/splits/test_cities.txt

@@ -0,0 +1,15 @@
+city_0005
+city_0007
+city_0008
+city_0010
+city_0012
+city_0013
+city_0020
+city_0028
+city_0042
+city_0047
+city_0051
+city_0065
+city_0069
+city_0075
+city_0084

data/splits/splits/train_cities.txt

@@ -0,0 +1,70 @@
+city_0001
+city_0002
+city_0003
+city_0004
+city_0006
+city_0011
+city_0014
+city_0015
+city_0017
+city_0018
+city_0019
+city_0021
+city_0022
+city_0023
+city_0024
+city_0025
+city_0026
+city_0027
+city_0030
+city_0032
+city_0033
+city_0034
+city_0035
+city_0036
+city_0037
+city_0038
+city_0039
+city_0040
+city_0041
+city_0043
+city_0044
+city_0045
+city_0046
+city_0048
+city_0049
+city_0050
+city_0052
+city_0053
+city_0057
+city_0058
+city_0059
+city_0060
+city_0061
+city_0062
+city_0063
+city_0064
+city_0066
+city_0067
+city_0068
+city_0070
+city_0072
+city_0074
+city_0076
+city_0077
+city_0079
+city_0080
+city_0081
+city_0082
+city_0083
+city_0085
+city_0087
+city_0088
+city_0089
+city_0092
+city_0093
+city_0094
+city_0095
+city_0097
+city_0099
+city_0100

data/splits/splits/val_cities.txt

@@ -0,0 +1,15 @@
+city_0009
+city_0016
+city_0029
+city_0031
+city_0054
+city_0055
+city_0056
+city_0071
+city_0073
+city_0078
+city_0086
+city_0090
+city_0091
+city_0096
+city_0098

server/environment.py

@@ -1,168 +1,168 @@
-from __future__ import annotations
-
-import os
-import uuid
-from pathlib import Path
-from typing import Any
-
-from district_llm.inference import DistrictLLMInference
-from district_llm.schema import DistrictAction
-from models import (
-    AgenticTrafficAction,
-    AgenticTrafficObservation,
-    AgenticTrafficState,
-)
-from openenv.core.env_server.interfaces import Environment
-from openenv_app.openenv_wrapper import OpenEnvTrafficWrapper
-
-
-REPO_ROOT = Path(__file__).resolve().parents[1]
-DATA_DIR = Path(os.environ.get("DATA_DIR", "") or (REPO_ROOT / "data" / "generated"))
-SPLITS_DIR = Path(os.environ.get("SPLITS_DIR", "") or (REPO_ROOT / "data" / "splits"))
-DISTRICT_LLM_ADAPTER_PATH = Path(
-    os.environ.get("DISTRICT_LLM_ADAPTER_PATH", "")
-    or (REPO_ROOT / "artifacts" / "district_llm_adapter_v3" / "main_run" / "adapter")
-)
-DISTRICT_LLM_DEVICE = os.environ.get("DISTRICT_LLM_DEVICE")
-
-
-class AgenticTrafficEnvironment(
-    Environment[AgenticTrafficAction, AgenticTrafficObservation, AgenticTrafficState]
-):
-    """Minimal OpenEnv-compatible wrapper around the existing district controller stack."""
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.wrapper = OpenEnvTrafficWrapper(
-            generated_root=DATA_DIR,
-            splits_root=SPLITS_DIR,
-        )
-        self._state = AgenticTrafficState()
-        self._llm_inference: DistrictLLMInference | None = None
-        self._llm_load_attempted = False
-        self._llm_error: str | None = None
-
-    def reset(
-        self,
-        seed: int | None = None,
-        episode_id: str | None = None,
-        **kwargs: Any,
-    ) -> AgenticTrafficObservation:
-        payload = self.wrapper.reset(
-            seed=seed,
-            city_id=kwargs.get("city_id"),
-            scenario_name=kwargs.get("scenario_name"),
-        )
-        self._state.episode_id = episode_id or str(uuid.uuid4())
-        self._state.step_count = 0
-        self._sync_state()
-        observation = AgenticTrafficObservation.model_validate(payload["observation"])
-        observation.reward = None
-        observation.done = False
-        observation.metadata["llm"] = self._llm_status()
-        return observation
-
-    def step(
-        self,
-        action: AgenticTrafficAction,
-        timeout_s: float | None = None,
-        **kwargs: Any,
-    ) -> AgenticTrafficObservation:
-        del timeout_s, kwargs
-        payload = self.wrapper.step(action=self._build_step_payload(action))
-        self._state.step_count += 1
-        self._sync_state()
-        observation = AgenticTrafficObservation.model_validate(payload["observation"])
-        observation.done = bool(payload.get("done", False))
-        observation.reward = float(payload.get("reward", 0.0))
-        observation.metadata["llm"] = self._llm_status()
-        return observation
-
-    @property
-    def state(self) -> AgenticTrafficState:
-        self._sync_state()
-        return self._state
-
-    def _build_step_payload(self, action: AgenticTrafficAction) -> dict[str, Any]:
-        district_actions = dict(action.district_actions)
-        llm_generated_actions: dict[str, Any] = {}
-
-        if action.use_llm:
-            llm_generated_actions = self._generate_llm_actions(
-                existing_actions=district_actions,
-                max_new_tokens=action.llm_max_new_tokens,
-            )
-            for district_id, directive in llm_generated_actions.items():
-                district_actions.setdefault(district_id, directive)
-
-        payload = {"district_actions": district_actions}
-        payload["metadata"] = {
-            "use_llm": bool(action.use_llm),
-            "llm_generated_districts": sorted(llm_generated_actions),
-            "llm": self._llm_status(),
-        }
-        return payload
-
-    def _generate_llm_actions(
-        self,
-        existing_actions: dict[str, Any],
-        max_new_tokens: int,
-    ) -> dict[str, Any]:
-        if not self.wrapper.last_summaries:
-            return {}
-
-        inference = self._get_llm_inference()
-        if inference is None:
-            return {}
-
-        generated_actions: dict[str, Any] = {}
-        for district_id, summary in self.wrapper.last_summaries.items():
-            if district_id in existing_actions:
-                continue
-            result = inference.predict_with_result(summary=summary, max_new_tokens=max_new_tokens)
-            generated_actions[district_id] = result.action.to_dict()
-        return generated_actions
-
-    def _get_llm_inference(self) -> DistrictLLMInference | None:
-        if self._llm_inference is not None:
-            return self._llm_inference
-        if self._llm_load_attempted:
-            return None
-
-        self._llm_load_attempted = True
-        if not DISTRICT_LLM_ADAPTER_PATH.exists():
-            self._llm_error = f"Adapter not found at {DISTRICT_LLM_ADAPTER_PATH}"
-            return None
-
-        try:
-            self._llm_inference = DistrictLLMInference(
-                model_name_or_path=str(DISTRICT_LLM_ADAPTER_PATH),
-                device=DISTRICT_LLM_DEVICE,
-                fallback_action=DistrictAction.default_hold(
-                    duration_steps=self.wrapper.district_decision_interval
-                ),
-            )
-        except Exception as exc:
-            self._llm_error = f"{type(exc).__name__}: {exc}"
-            self._llm_inference = None
-        return self._llm_inference
-
-    def _llm_status(self) -> dict[str, Any]:
-        return {
-            "adapter_path": str(DISTRICT_LLM_ADAPTER_PATH),
-            "adapter_present": DISTRICT_LLM_ADAPTER_PATH.exists(),
-            "loaded": self._llm_inference is not None,
-            "load_attempted": self._llm_load_attempted,
-            "error": self._llm_error,
-        }
-
-    def _sync_state(self) -> None:
-        payload = self.wrapper.state()["state"]
-        self._state = AgenticTrafficState.model_validate(
-            {
-                **payload,
-                "episode_id": self._state.episode_id,
-                "step_count": self._state.step_count,
-                "llm": self._llm_status(),
-            }
-        )
+from __future__ import annotations
+
+import os
+import uuid
+from pathlib import Path
+from typing import Any
+
+from district_llm.inference import DistrictLLMInference
+from district_llm.schema import DistrictAction
+from models import (
+    AgenticTrafficAction,
+    AgenticTrafficObservation,
+    AgenticTrafficState,
+)
+from openenv.core.env_server.interfaces import Environment
+from openenv_app.openenv_wrapper import OpenEnvTrafficWrapper
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+DATA_DIR = Path(os.environ.get("DATA_DIR", "") or (REPO_ROOT / "data" / "generated"))
+SPLITS_DIR = Path(os.environ.get("SPLITS_DIR", "") or (REPO_ROOT / "data" / "splits"))
+DISTRICT_LLM_ADAPTER_PATH = Path(
+    os.environ.get("DISTRICT_LLM_ADAPTER_PATH", "")
+    or (REPO_ROOT / "artifacts" / "district_llm_adapter_v3" / "main_run" / "adapter")
+)
+DISTRICT_LLM_DEVICE = os.environ.get("DISTRICT_LLM_DEVICE")
+
+
+class AgenticTrafficEnvironment(
+    Environment[AgenticTrafficAction, AgenticTrafficObservation, AgenticTrafficState]
+):
+    """Minimal OpenEnv-compatible wrapper around the existing district controller stack."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.wrapper = OpenEnvTrafficWrapper(
+            generated_root=DATA_DIR,
+            splits_root=SPLITS_DIR,
+        )
+        self._state = AgenticTrafficState()
+        self._llm_inference: DistrictLLMInference | None = None
+        self._llm_load_attempted = False
+        self._llm_error: str | None = None
+
+    def reset(
+        self,
+        seed: int | None = None,
+        episode_id: str | None = None,
+        **kwargs: Any,
+    ) -> AgenticTrafficObservation:
+        payload = self.wrapper.reset(
+            seed=seed,
+            city_id=kwargs.get("city_id"),
+            scenario_name=kwargs.get("scenario_name"),
+        )
+        self._state.episode_id = episode_id or str(uuid.uuid4())
+        self._state.step_count = 0
+        self._sync_state()
+        observation = AgenticTrafficObservation.model_validate(payload["observation"])
+        observation.reward = None
+        observation.done = False
+        observation.metadata["llm"] = self._llm_status()
+        return observation
+
+    def step(
+        self,
+        action: AgenticTrafficAction,
+        timeout_s: float | None = None,
+        **kwargs: Any,
+    ) -> AgenticTrafficObservation:
+        del timeout_s, kwargs
+        payload = self.wrapper.step(action=self._build_step_payload(action))
+        self._state.step_count += 1
+        self._sync_state()
+        observation = AgenticTrafficObservation.model_validate(payload["observation"])
+        observation.done = bool(payload.get("done", False))
+        observation.reward = float(payload.get("reward", 0.0))
+        observation.metadata["llm"] = self._llm_status()
+        return observation
+
+    @property
+    def state(self) -> AgenticTrafficState:
+        self._sync_state()
+        return self._state
+
+    def _build_step_payload(self, action: AgenticTrafficAction) -> dict[str, Any]:
+        district_actions = dict(action.district_actions)
+        llm_generated_actions: dict[str, Any] = {}
+
+        if action.use_llm:
+            llm_generated_actions = self._generate_llm_actions(
+                existing_actions=district_actions,
+                max_new_tokens=action.llm_max_new_tokens,
+            )
+            for district_id, directive in llm_generated_actions.items():
+                district_actions.setdefault(district_id, directive)
+
+        payload = {"district_actions": district_actions}
+        payload["metadata"] = {
+            "use_llm": bool(action.use_llm),
+            "llm_generated_districts": sorted(llm_generated_actions),
+            "llm": self._llm_status(),
+        }
+        return payload
+
+    def _generate_llm_actions(
+        self,
+        existing_actions: dict[str, Any],
+        max_new_tokens: int,
+    ) -> dict[str, Any]:
+        if not self.wrapper.last_summaries:
+            return {}
+
+        inference = self._get_llm_inference()
+        if inference is None:
+            return {}
+
+        generated_actions: dict[str, Any] = {}
+        for district_id, summary in self.wrapper.last_summaries.items():
+            if district_id in existing_actions:
+                continue
+            result = inference.predict_with_result(summary=summary, max_new_tokens=max_new_tokens)
+            generated_actions[district_id] = result.action.to_dict()
+        return generated_actions
+
+    def _get_llm_inference(self) -> DistrictLLMInference | None:
+        if self._llm_inference is not None:
+            return self._llm_inference
+        if self._llm_load_attempted:
+            return None
+
+        self._llm_load_attempted = True
+        if not DISTRICT_LLM_ADAPTER_PATH.exists():
+            self._llm_error = f"Adapter not found at {DISTRICT_LLM_ADAPTER_PATH}"
+            return None
+
+        try:
+            self._llm_inference = DistrictLLMInference(
+                model_name_or_path=str(DISTRICT_LLM_ADAPTER_PATH),
+                device=DISTRICT_LLM_DEVICE,
+                fallback_action=DistrictAction.default_hold(
+                    duration_steps=self.wrapper.district_decision_interval
+                ),
+            )
+        except Exception as exc:
+            self._llm_error = f"{type(exc).__name__}: {exc}"
+            self._llm_inference = None
+        return self._llm_inference
+
+    def _llm_status(self) -> dict[str, Any]:
+        return {
+            "adapter_path": str(DISTRICT_LLM_ADAPTER_PATH),
+            "adapter_present": DISTRICT_LLM_ADAPTER_PATH.exists(),
+            "loaded": self._llm_inference is not None,
+            "load_attempted": self._llm_load_attempted,
+            "error": self._llm_error,
+        }
+
+    def _sync_state(self) -> None:
+        payload = self.wrapper.state()["state"]
+        self._state = AgenticTrafficState.model_validate(
+            {
+                **payload,
+                "episode_id": self._state.episode_id,
+                "step_count": self._state.step_count,
+                "llm": self._llm_status(),
+            }
+        )

server/remote_runner.py

@@ -1,58 +1,58 @@
-"""HTTP client that delegates simulation runs to a remote OpenEnv API Space."""
-from __future__ import annotations
-
-import json
-import logging
-from pathlib import Path
-from typing import Any
-
-import httpx
-
-logger = logging.getLogger(__name__)
-
-
-def run_policy_remote(
-    city_id: str,
-    scenario_name: str,
-    policy_name: str,
-    openenv_api_url: str,
-    output_root: Path,
-    timeout: float = 120.0,
-):
-    """Call Space 1's /replay endpoint and write results to output_root."""
-    from server.policy_runner import RunResult
-
-    url = f"{openenv_api_url.rstrip('/')}/replay/{city_id}/{scenario_name}/{policy_name}"
-    logger.info("Remote replay request: %s", url)
-
-    with httpx.Client(timeout=timeout) as client:
-        resp = client.get(url)
-        resp.raise_for_status()
-
-    payload: dict[str, Any] = resp.json()
-
-    output_dir = output_root / city_id / scenario_name / policy_name
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    replay_path = output_dir / "replay.txt"
-    replay_path.write_text(payload["replay_text"], encoding="utf-8")
-
-    roadnet_log_path = output_dir / "roadnetLogFile.json"
-    if payload.get("roadnet_log"):
-        roadnet_log_path.write_text(
-            json.dumps(payload["roadnet_log"], indent=2), encoding="utf-8"
-        )
-
-    metrics_path = output_dir / "metrics.json"
-    metrics_path.write_text(
-        json.dumps(payload.get("metrics", {}), indent=2), encoding="utf-8"
-    )
-
-    return RunResult(
-        city_id=city_id,
-        scenario_name=scenario_name,
-        policy_name=policy_name,
-        replay_path=replay_path,
-        roadnet_log_path=roadnet_log_path,
-        metrics=payload.get("metrics", {}),
-    )
+"""HTTP client that delegates simulation runs to a remote OpenEnv API Space."""
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+def run_policy_remote(
+    city_id: str,
+    scenario_name: str,
+    policy_name: str,
+    openenv_api_url: str,
+    output_root: Path,
+    timeout: float = 120.0,
+):
+    """Call Space 1's /replay endpoint and write results to output_root."""
+    from server.policy_runner import RunResult
+
+    url = f"{openenv_api_url.rstrip('/')}/replay/{city_id}/{scenario_name}/{policy_name}"
+    logger.info("Remote replay request: %s", url)
+
+    with httpx.Client(timeout=timeout) as client:
+        resp = client.get(url)
+        resp.raise_for_status()
+
+    payload: dict[str, Any] = resp.json()
+
+    output_dir = output_root / city_id / scenario_name / policy_name
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    replay_path = output_dir / "replay.txt"
+    replay_path.write_text(payload["replay_text"], encoding="utf-8")
+
+    roadnet_log_path = output_dir / "roadnetLogFile.json"
+    if payload.get("roadnet_log"):
+        roadnet_log_path.write_text(
+            json.dumps(payload["roadnet_log"], indent=2), encoding="utf-8"
+        )
+
+    metrics_path = output_dir / "metrics.json"
+    metrics_path.write_text(
+        json.dumps(payload.get("metrics", {}), indent=2), encoding="utf-8"
+    )
+
+    return RunResult(
+        city_id=city_id,
+        scenario_name=scenario_name,
+        policy_name=policy_name,
+        replay_path=replay_path,
+        roadnet_log_path=roadnet_log_path,
+        metrics=payload.get("metrics", {}),
+    )

server/roadnet_matcher.py

@@ -1,55 +1,55 @@
-"""Match an uploaded roadnet.json to a known city in the dataset by fingerprint."""
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-
-def match_city_by_roadnet(roadnet_data: dict, generated_root: Path) -> str | None:
-    """Return the city_id whose roadnet.json matches the uploaded data, or None."""
-    uploaded_fp = _fingerprint(roadnet_data)
-    if not uploaded_fp:
-        return None
-
-    for city_dir in sorted(generated_root.glob("city_*")):
-        roadnet_path = city_dir / "roadnet.json"
-        if not roadnet_path.exists():
-            continue
-        try:
-            candidate = json.loads(roadnet_path.read_text())
-            if _fingerprint(candidate) == uploaded_fp:
-                return city_dir.name
-        except Exception:
-            continue
-
-    return None
-
-
-def list_all_cities(generated_root: Path) -> list[str]:
-    return sorted(
-        d.name
-        for d in generated_root.glob("city_*")
-        if d.is_dir() and (d / "roadnet.json").exists()
-    )
-
-
-def list_scenarios_for_city(city_id: str, generated_root: Path) -> list[str]:
-    scenario_root = generated_root / city_id / "scenarios"
-    if not scenario_root.exists():
-        return []
-    return sorted(
-        d.name
-        for d in scenario_root.iterdir()
-        if d.is_dir()
-        and (d / "config.json").exists()
-        and (d / "flow.json").exists()
-    )
-
-
-def _fingerprint(roadnet: dict) -> frozenset[str]:
-    """Fingerprint = set of non-virtual intersection IDs."""
-    return frozenset(
-        item["id"]
-        for item in roadnet.get("intersections", [])
-        if not item.get("virtual", False) and item.get("id")
-    )
+"""Match an uploaded roadnet.json to a known city in the dataset by fingerprint."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+def match_city_by_roadnet(roadnet_data: dict, generated_root: Path) -> str | None:
+    """Return the city_id whose roadnet.json matches the uploaded data, or None."""
+    uploaded_fp = _fingerprint(roadnet_data)
+    if not uploaded_fp:
+        return None
+
+    for city_dir in sorted(generated_root.glob("city_*")):
+        roadnet_path = city_dir / "roadnet.json"
+        if not roadnet_path.exists():
+            continue
+        try:
+            candidate = json.loads(roadnet_path.read_text())
+            if _fingerprint(candidate) == uploaded_fp:
+                return city_dir.name
+        except Exception:
+            continue
+
+    return None
+
+
+def list_all_cities(generated_root: Path) -> list[str]:
+    return sorted(
+        d.name
+        for d in generated_root.glob("city_*")
+        if d.is_dir() and (d / "roadnet.json").exists()
+    )
+
+
+def list_scenarios_for_city(city_id: str, generated_root: Path) -> list[str]:
+    scenario_root = generated_root / city_id / "scenarios"
+    if not scenario_root.exists():
+        return []
+    return sorted(
+        d.name
+        for d in scenario_root.iterdir()
+        if d.is_dir()
+        and (d / "config.json").exists()
+        and (d / "flow.json").exists()
+    )
+
+
+def _fingerprint(roadnet: dict) -> frozenset[str]:
+    """Fingerprint = set of non-virtual intersection IDs."""
+    return frozenset(
+        item["id"]
+        for item in roadnet.get("intersections", [])
+        if not item.get("virtual", False) and item.get("id")
+    )

server/visualizer_app.py

@@ -1,404 +1,404 @@
-"""FastAPI visualizer server for CityFlow multi-policy comparison dashboard.
-
-Deployment modes
-----------------
-Local (no OPENENV_API_URL set):
-    Runs CityFlow simulations in-process via ``server.policy_runner``.
-
-HF Space 2 (OPENENV_API_URL set to Space 1's URL):
-    Delegates all simulation runs to the remote OpenEnv API via
-    ``server.remote_runner``.  No CityFlow or torch needed locally.
-"""
-from __future__ import annotations
-
-import json
-import logging
-import os
-import sys
-import time
-from contextlib import asynccontextmanager
-from pathlib import Path
-from typing import Any
-
-import httpx
-from fastapi import FastAPI, HTTPException, UploadFile
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse, JSONResponse, PlainTextResponse
-from fastapi.staticfiles import StaticFiles
-from joblib import Parallel, delayed
-from pydantic import BaseModel
-
-REPO_ROOT = Path(__file__).resolve().parents[1]
-if str(REPO_ROOT) not in sys.path:
-    sys.path.insert(0, str(REPO_ROOT))
-
-logger = logging.getLogger(__name__)
-
-# ---------------------------------------------------------------------------
-# Configuration — all overridable via environment variables
-# ---------------------------------------------------------------------------
-
-OPENENV_API_URL: str | None = os.environ.get("OPENENV_API_URL") or None
-
-GENERATED_ROOT = Path(
-    os.environ.get("DATA_DIR", "") or (REPO_ROOT / "data" / "generated")
-)
-REPLAY_OUTPUT_ROOT = Path(
-    os.environ.get("REPLAY_ROOT", "") or (REPO_ROOT / "results" / "replays")
-)
-CHECKPOINT_PATH = Path(
-    os.environ.get("CHECKPOINT_PATH", "")
-    or (REPO_ROOT / "artifacts" / "dqn_shared" / "best_validation.pt")
-)
-FRONTEND_DIR = REPO_ROOT / "third_party" / "CityFlow" / "frontend"
-
-# ---------------------------------------------------------------------------
-# Runner selection: local (policy_runner) vs. remote (remote_runner)
-# ---------------------------------------------------------------------------
-
-from server.path_validators import validate_path_segment
-from server.policy_runner import ALL_POLICIES, RunResult
-
-if OPENENV_API_URL:
-    logger.info("Remote mode — OpenEnv API at %s", OPENENV_API_URL)
-    from server.remote_runner import run_policy_remote as _run_remote
-
-    def _run_policy(city_id: str, scenario_name: str, policy_name: str) -> RunResult:
-        return _run_remote(
-            city_id=city_id,
-            scenario_name=scenario_name,
-            policy_name=policy_name,
-            openenv_api_url=OPENENV_API_URL,  # type: ignore[arg-type]
-            output_root=REPLAY_OUTPUT_ROOT,
-        )
-
-else:
-    logger.info("Local mode — running CityFlow in-process")
-    from server.policy_runner import run_policy_for_city as _run_local
-
-    def _run_policy(city_id: str, scenario_name: str, policy_name: str) -> RunResult:
-        return _run_local(
-            city_id=city_id,
-            scenario_name=scenario_name,
-            policy_name=policy_name,
-            generated_root=GENERATED_ROOT,
-            output_root=REPLAY_OUTPUT_ROOT,
-        )
-
-
-from server.roadnet_matcher import (
-    list_all_cities,
-    list_scenarios_for_city,
-    match_city_by_roadnet,
-)
-
-# ---------------------------------------------------------------------------
-# Lifespan
-# ---------------------------------------------------------------------------
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    REPLAY_OUTPUT_ROOT.mkdir(parents=True, exist_ok=True)
-
-    if OPENENV_API_URL:
-        try:
-            with httpx.Client(timeout=10.0) as client:
-                resp = client.get(f"{OPENENV_API_URL.rstrip('/')}/health")
-                resp.raise_for_status()
-            logger.info("OpenEnv API health check passed: %s", OPENENV_API_URL)
-        except Exception as exc:
-            logger.warning(
-                "OpenEnv API at %s did not respond to /health: %s. "
-                "Simulation requests will fail until it is reachable.",
-                OPENENV_API_URL,
-                exc,
-            )
-    else:
-        from server.policy_runner import load_district_llm_inference, load_dqn_checkpoint
-        if CHECKPOINT_PATH.exists():
-            load_dqn_checkpoint(CHECKPOINT_PATH)
-        else:
-            logger.warning("Checkpoint not found at %s — 'learned' policy will fail", CHECKPOINT_PATH)
-        try:
-            load_district_llm_inference()
-        except Exception as exc:
-            logger.warning(
-                "District LLM prewarm failed: %s. "
-                "The llm_dqn policy will retry loading lazily on first use.",
-                exc,
-            )
-
-    yield
-
-    if not OPENENV_API_URL:
-        from server.policy_runner import unload_district_llm_inference
-
-        try:
-            unload_district_llm_inference()
-        except Exception as exc:
-            logger.warning("District LLM unload failed during shutdown: %s", exc)
-
-
-# ---------------------------------------------------------------------------
-# App setup
-# ---------------------------------------------------------------------------
-
-app = FastAPI(
-    title="Traffic Visualizer",
-    description="Multi-policy CityFlow replay comparison dashboard.",
-    version="1.0.0",
-    lifespan=lifespan,
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-app.mount("/static", StaticFiles(directory=str(FRONTEND_DIR)), name="frontend")
-
-# ---------------------------------------------------------------------------
-# Request / response models
-# ---------------------------------------------------------------------------
-
-
-class RunSimulationsRequest(BaseModel):
-    city_id: str
-    scenario_name: str
-    policies: list[str] = list(ALL_POLICIES)
-    force: bool = False
-
-
-class PolicyMetrics(BaseModel):
-    policy_name: str
-    metrics: dict[str, Any]
-    replay_available: bool
-    roadnet_log_available: bool
-    elapsed_ms: float | None = None
-
-
-class RunSimulationsResponse(BaseModel):
-    city_id: str
-    scenario_name: str
-    results: list[PolicyMetrics]
-
-
-# ---------------------------------------------------------------------------
-# Endpoints
-# ---------------------------------------------------------------------------
-
-
-@app.get("/")
-def root():
-    index_path = FRONTEND_DIR / "index.html"
-    if index_path.exists():
-        return FileResponse(str(index_path))
-    return JSONResponse({"status": "Traffic Visualizer API running"})
-
-
-@app.post("/upload-roadnet")
-async def upload_roadnet(file: UploadFile) -> dict:
-    raw = await file.read()
-    try:
-        roadnet_data = json.loads(raw)
-    except json.JSONDecodeError as exc:
-        raise HTTPException(status_code=400, detail=f"Invalid JSON: {exc}")
-
-    city_id = match_city_by_roadnet(roadnet_data, GENERATED_ROOT)
-    if city_id is None:
-        return {
-            "matched": False,
-            "city_id": None,
-            "scenarios": [],
-            "all_cities": list_all_cities(GENERATED_ROOT),
-        }
-
-    scenarios = list_scenarios_for_city(city_id, GENERATED_ROOT)
-    return {"matched": True, "city_id": city_id, "scenarios": scenarios, "all_cities": []}
-
-
-@app.get("/cities")
-def get_cities() -> dict:
-    return {"cities": list_all_cities(GENERATED_ROOT)}
-
-
-@app.get("/cities/{city_id}/scenarios")
-def get_scenarios(city_id: str) -> dict:
-    validate_path_segment(city_id, "city_id")
-    scenarios = list_scenarios_for_city(city_id, GENERATED_ROOT)
-    if not scenarios:
-        raise HTTPException(
-            status_code=404,
-            detail=f"City '{city_id}' not found or has no scenarios.",
-        )
-    return {"city_id": city_id, "scenarios": scenarios}
-
-
-@app.get("/cities/{city_id}/district-map")
-def get_district_map(city_id: str) -> JSONResponse:
-    validate_path_segment(city_id, "city_id")
-    district_map_path = GENERATED_ROOT / city_id / "district_map.json"
-    if not district_map_path.exists():
-        raise HTTPException(
-            status_code=404,
-            detail=f"District map not found for city '{city_id}'.",
-        )
-    return JSONResponse(json.loads(district_map_path.read_text(encoding="utf-8")))
-
-
-@app.post("/run-simulations", response_model=RunSimulationsResponse)
-def run_simulations(request: RunSimulationsRequest) -> RunSimulationsResponse:
-    validate_path_segment(request.city_id, "city_id")
-    validate_path_segment(request.scenario_name, "scenario_name")
-
-    valid_policies = set(ALL_POLICIES)
-    bad = [p for p in request.policies if p not in valid_policies]
-    if bad:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unknown policies: {bad}. Valid: {list(ALL_POLICIES)}",
-        )
-
-    def _run_one(policy_name: str) -> PolicyMetrics:
-        started_at = time.perf_counter()
-        output_dir = REPLAY_OUTPUT_ROOT / request.city_id / request.scenario_name / policy_name
-        replay_path = output_dir / "replay.txt"
-        roadnet_path = output_dir / "roadnetLogFile.json"
-        metrics_path = output_dir / "metrics.json"
-
-        if not request.force and replay_path.exists() and metrics_path.exists():
-            return PolicyMetrics(
-                policy_name=policy_name,
-                metrics=json.loads(metrics_path.read_text(encoding="utf-8")),
-                replay_available=True,
-                roadnet_log_available=roadnet_path.exists(),
-                elapsed_ms=0.0,
-            )
-
-        try:
-            result: RunResult = _run_policy(
-                city_id=request.city_id,
-                scenario_name=request.scenario_name,
-                policy_name=policy_name,
-            )
-            return PolicyMetrics(
-                policy_name=policy_name,
-                metrics=result.metrics,
-                replay_available=result.replay_path.exists(),
-                roadnet_log_available=result.roadnet_log_path.exists(),
-                elapsed_ms=(time.perf_counter() - started_at) * 1000.0,
-            )
-        except Exception as exc:
-            logger.error("Policy run failed for %s/%s/%s: %s", request.city_id, request.scenario_name, policy_name, exc)
-            return PolicyMetrics(
-                policy_name=policy_name,
-                metrics={"error": "Simulation failed. Check server logs."},
-                replay_available=False,
-                roadnet_log_available=False,
-                elapsed_ms=(time.perf_counter() - started_at) * 1000.0,
-            )
-
-    n_jobs = min(len(request.policies), 4)
-    results: list[PolicyMetrics] = Parallel(
-        n_jobs=n_jobs, prefer="threads"
-    )(delayed(_run_one)(p) for p in request.policies)
-
-    return RunSimulationsResponse(
-        city_id=request.city_id,
-        scenario_name=request.scenario_name,
-        results=results,
-    )
-
-
-@app.get("/replay/{city_id}/{scenario_name}/{policy_name}", response_model=None)
-def get_replay(
-    city_id: str,
-    scenario_name: str,
-    policy_name: str,
-    max_steps: int = 0,
-) -> PlainTextResponse | FileResponse:
-    validate_path_segment(city_id, "city_id")
-    validate_path_segment(scenario_name, "scenario_name")
-    validate_path_segment(policy_name, "policy_name")
-
-    replay_path = REPLAY_OUTPUT_ROOT / city_id / scenario_name / policy_name / "replay.txt"
-    if not replay_path.exists():
-        raise HTTPException(
-            status_code=404,
-            detail=f"Replay not found for {city_id}/{scenario_name}/{policy_name}. Run /run-simulations first.",
-        )
-    if max_steps > 0:
-        lines: list[str] = []
-        with open(replay_path, encoding="utf-8") as fh:
-            for raw in fh:
-                if raw.strip():
-                    lines.append(raw.rstrip("\n"))
-                    if len(lines) >= max_steps:
-                        break
-        return PlainTextResponse("\n".join(lines))
-    return FileResponse(str(replay_path), media_type="text/plain")
-
-
-@app.get("/roadnet-log/{city_id}/{scenario_name}/{policy_name}")
-def get_roadnet_log(city_id: str, scenario_name: str, policy_name: str) -> JSONResponse:
-    validate_path_segment(city_id, "city_id")
-    validate_path_segment(scenario_name, "scenario_name")
-    validate_path_segment(policy_name, "policy_name")
-
-    path = REPLAY_OUTPUT_ROOT / city_id / scenario_name / policy_name / "roadnetLogFile.json"
-    if not path.exists():
-        for p in ALL_POLICIES:
-            fallback = REPLAY_OUTPUT_ROOT / city_id / scenario_name / p / "roadnetLogFile.json"
-            if fallback.exists():
-                path = fallback
-                break
-    if not path.exists():
-        raise HTTPException(
-            status_code=404,
-            detail=f"Roadnet log not found for {city_id}/{scenario_name}.",
-        )
-    return JSONResponse(json.loads(path.read_text(encoding="utf-8")))
-
-
-@app.get("/metrics/{city_id}/{scenario_name}")
-def get_metrics(city_id: str, scenario_name: str) -> dict:
-    validate_path_segment(city_id, "city_id")
-    validate_path_segment(scenario_name, "scenario_name")
-
-    base = REPLAY_OUTPUT_ROOT / city_id / scenario_name
-    if not base.exists():
-        raise HTTPException(
-            status_code=404,
-            detail=f"No simulation results found for {city_id}/{scenario_name}.",
-        )
-
-    metrics: dict[str, Any] = {}
-    for policy_dir in sorted(base.iterdir()):
-        if not policy_dir.is_dir():
-            continue
-        metrics_path = policy_dir / "metrics.json"
-        replay_path = policy_dir / "replay.txt"
-        roadnet_log_path = policy_dir / "roadnetLogFile.json"
-        payload: dict[str, Any] = {}
-        if metrics_path.exists():
-            payload.update(json.loads(metrics_path.read_text(encoding="utf-8")))
-        if replay_path.exists():
-            payload["replay_available"] = True
-        if roadnet_log_path.exists():
-            payload["roadnet_log_available"] = True
-        if payload:
-            metrics[policy_dir.name] = payload
-
-    return {"city_id": city_id, "scenario_name": scenario_name, "metrics": metrics}
-
-
-# ---------------------------------------------------------------------------
-# Entry point
-# ---------------------------------------------------------------------------
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run("server.visualizer_app:app", host="0.0.0.0", port=8080, reload=False)
+"""FastAPI visualizer server for CityFlow multi-policy comparison dashboard.
+
+Deployment modes
+----------------
+Local (no OPENENV_API_URL set):
+    Runs CityFlow simulations in-process via ``server.policy_runner``.
+
+HF Space 2 (OPENENV_API_URL set to Space 1's URL):
+    Delegates all simulation runs to the remote OpenEnv API via
+    ``server.remote_runner``.  No CityFlow or torch needed locally.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sys
+import time
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any
+
+import httpx
+from fastapi import FastAPI, HTTPException, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, JSONResponse, PlainTextResponse
+from fastapi.staticfiles import StaticFiles
+from joblib import Parallel, delayed
+from pydantic import BaseModel
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Configuration — all overridable via environment variables
+# ---------------------------------------------------------------------------
+
+OPENENV_API_URL: str | None = os.environ.get("OPENENV_API_URL") or None
+
+GENERATED_ROOT = Path(
+    os.environ.get("DATA_DIR", "") or (REPO_ROOT / "data" / "generated")
+)
+REPLAY_OUTPUT_ROOT = Path(
+    os.environ.get("REPLAY_ROOT", "") or (REPO_ROOT / "results" / "replays")
+)
+CHECKPOINT_PATH = Path(
+    os.environ.get("CHECKPOINT_PATH", "")
+    or (REPO_ROOT / "artifacts" / "dqn_shared" / "best_validation.pt")
+)
+FRONTEND_DIR = REPO_ROOT / "third_party" / "CityFlow" / "frontend"
+
+# ---------------------------------------------------------------------------
+# Runner selection: local (policy_runner) vs. remote (remote_runner)
+# ---------------------------------------------------------------------------
+
+from server.path_validators import validate_path_segment
+from server.policy_runner import ALL_POLICIES, RunResult
+
+if OPENENV_API_URL:
+    logger.info("Remote mode — OpenEnv API at %s", OPENENV_API_URL)
+    from server.remote_runner import run_policy_remote as _run_remote
+
+    def _run_policy(city_id: str, scenario_name: str, policy_name: str) -> RunResult:
+        return _run_remote(
+            city_id=city_id,
+            scenario_name=scenario_name,
+            policy_name=policy_name,
+            openenv_api_url=OPENENV_API_URL,  # type: ignore[arg-type]
+            output_root=REPLAY_OUTPUT_ROOT,
+        )
+
+else:
+    logger.info("Local mode — running CityFlow in-process")
+    from server.policy_runner import run_policy_for_city as _run_local
+
+    def _run_policy(city_id: str, scenario_name: str, policy_name: str) -> RunResult:
+        return _run_local(
+            city_id=city_id,
+            scenario_name=scenario_name,
+            policy_name=policy_name,
+            generated_root=GENERATED_ROOT,
+            output_root=REPLAY_OUTPUT_ROOT,
+        )
+
+
+from server.roadnet_matcher import (
+    list_all_cities,
+    list_scenarios_for_city,
+    match_city_by_roadnet,
+)
+
+# ---------------------------------------------------------------------------
+# Lifespan
+# ---------------------------------------------------------------------------
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    REPLAY_OUTPUT_ROOT.mkdir(parents=True, exist_ok=True)
+
+    if OPENENV_API_URL:
+        try:
+            with httpx.Client(timeout=10.0) as client:
+                resp = client.get(f"{OPENENV_API_URL.rstrip('/')}/health")
+                resp.raise_for_status()
+            logger.info("OpenEnv API health check passed: %s", OPENENV_API_URL)
+        except Exception as exc:
+            logger.warning(
+                "OpenEnv API at %s did not respond to /health: %s. "
+                "Simulation requests will fail until it is reachable.",
+                OPENENV_API_URL,
+                exc,
+            )
+    else:
+        from server.policy_runner import load_district_llm_inference, load_dqn_checkpoint
+        if CHECKPOINT_PATH.exists():
+            load_dqn_checkpoint(CHECKPOINT_PATH)
+        else:
+            logger.warning("Checkpoint not found at %s — 'learned' policy will fail", CHECKPOINT_PATH)
+        try:
+            load_district_llm_inference()
+        except Exception as exc:
+            logger.warning(
+                "District LLM prewarm failed: %s. "
+                "The llm_dqn policy will retry loading lazily on first use.",
+                exc,
+            )
+
+    yield
+
+    if not OPENENV_API_URL:
+        from server.policy_runner import unload_district_llm_inference
+
+        try:
+            unload_district_llm_inference()
+        except Exception as exc:
+            logger.warning("District LLM unload failed during shutdown: %s", exc)
+
+
+# ---------------------------------------------------------------------------
+# App setup
+# ---------------------------------------------------------------------------
+
+app = FastAPI(
+    title="Traffic Visualizer",
+    description="Multi-policy CityFlow replay comparison dashboard.",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.mount("/static", StaticFiles(directory=str(FRONTEND_DIR)), name="frontend")
+
+# ---------------------------------------------------------------------------
+# Request / response models
+# ---------------------------------------------------------------------------
+
+
+class RunSimulationsRequest(BaseModel):
+    city_id: str
+    scenario_name: str
+    policies: list[str] = list(ALL_POLICIES)
+    force: bool = False
+
+
+class PolicyMetrics(BaseModel):
+    policy_name: str
+    metrics: dict[str, Any]
+    replay_available: bool
+    roadnet_log_available: bool
+    elapsed_ms: float | None = None
+
+
+class RunSimulationsResponse(BaseModel):
+    city_id: str
+    scenario_name: str
+    results: list[PolicyMetrics]
+
+
+# ---------------------------------------------------------------------------
+# Endpoints
+# ---------------------------------------------------------------------------
+
+
+@app.get("/")
+def root():
+    index_path = FRONTEND_DIR / "index.html"
+    if index_path.exists():
+        return FileResponse(str(index_path))
+    return JSONResponse({"status": "Traffic Visualizer API running"})
+
+
+@app.post("/upload-roadnet")
+async def upload_roadnet(file: UploadFile) -> dict:
+    raw = await file.read()
+    try:
+        roadnet_data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise HTTPException(status_code=400, detail=f"Invalid JSON: {exc}")
+
+    city_id = match_city_by_roadnet(roadnet_data, GENERATED_ROOT)
+    if city_id is None:
+        return {
+            "matched": False,
+            "city_id": None,
+            "scenarios": [],
+            "all_cities": list_all_cities(GENERATED_ROOT),
+        }
+
+    scenarios = list_scenarios_for_city(city_id, GENERATED_ROOT)
+    return {"matched": True, "city_id": city_id, "scenarios": scenarios, "all_cities": []}
+
+
+@app.get("/cities")
+def get_cities() -> dict:
+    return {"cities": list_all_cities(GENERATED_ROOT)}
+
+
+@app.get("/cities/{city_id}/scenarios")
+def get_scenarios(city_id: str) -> dict:
+    validate_path_segment(city_id, "city_id")
+    scenarios = list_scenarios_for_city(city_id, GENERATED_ROOT)
+    if not scenarios:
+        raise HTTPException(
+            status_code=404,
+            detail=f"City '{city_id}' not found or has no scenarios.",
+        )
+    return {"city_id": city_id, "scenarios": scenarios}
+
+
+@app.get("/cities/{city_id}/district-map")
+def get_district_map(city_id: str) -> JSONResponse:
+    validate_path_segment(city_id, "city_id")
+    district_map_path = GENERATED_ROOT / city_id / "district_map.json"
+    if not district_map_path.exists():
+        raise HTTPException(
+            status_code=404,
+            detail=f"District map not found for city '{city_id}'.",
+        )
+    return JSONResponse(json.loads(district_map_path.read_text(encoding="utf-8")))
+
+
+@app.post("/run-simulations", response_model=RunSimulationsResponse)
+def run_simulations(request: RunSimulationsRequest) -> RunSimulationsResponse:
+    validate_path_segment(request.city_id, "city_id")
+    validate_path_segment(request.scenario_name, "scenario_name")
+
+    valid_policies = set(ALL_POLICIES)
+    bad = [p for p in request.policies if p not in valid_policies]
+    if bad:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unknown policies: {bad}. Valid: {list(ALL_POLICIES)}",
+        )
+
+    def _run_one(policy_name: str) -> PolicyMetrics:
+        started_at = time.perf_counter()
+        output_dir = REPLAY_OUTPUT_ROOT / request.city_id / request.scenario_name / policy_name
+        replay_path = output_dir / "replay.txt"
+        roadnet_path = output_dir / "roadnetLogFile.json"
+        metrics_path = output_dir / "metrics.json"
+
+        if not request.force and replay_path.exists() and metrics_path.exists():
+            return PolicyMetrics(
+                policy_name=policy_name,
+                metrics=json.loads(metrics_path.read_text(encoding="utf-8")),
+                replay_available=True,
+                roadnet_log_available=roadnet_path.exists(),
+                elapsed_ms=0.0,
+            )
+
+        try:
+            result: RunResult = _run_policy(
+                city_id=request.city_id,
+                scenario_name=request.scenario_name,
+                policy_name=policy_name,
+            )
+            return PolicyMetrics(
+                policy_name=policy_name,
+                metrics=result.metrics,
+                replay_available=result.replay_path.exists(),
+                roadnet_log_available=result.roadnet_log_path.exists(),
+                elapsed_ms=(time.perf_counter() - started_at) * 1000.0,
+            )
+        except Exception as exc:
+            logger.error("Policy run failed for %s/%s/%s: %s", request.city_id, request.scenario_name, policy_name, exc)
+            return PolicyMetrics(
+                policy_name=policy_name,
+                metrics={"error": "Simulation failed. Check server logs."},
+                replay_available=False,
+                roadnet_log_available=False,
+                elapsed_ms=(time.perf_counter() - started_at) * 1000.0,
+            )
+
+    n_jobs = min(len(request.policies), 4)
+    results: list[PolicyMetrics] = Parallel(
+        n_jobs=n_jobs, prefer="threads"
+    )(delayed(_run_one)(p) for p in request.policies)
+
+    return RunSimulationsResponse(
+        city_id=request.city_id,
+        scenario_name=request.scenario_name,
+        results=results,
+    )
+
+
+@app.get("/replay/{city_id}/{scenario_name}/{policy_name}", response_model=None)
+def get_replay(
+    city_id: str,
+    scenario_name: str,
+    policy_name: str,
+    max_steps: int = 0,
+) -> PlainTextResponse | FileResponse:
+    validate_path_segment(city_id, "city_id")
+    validate_path_segment(scenario_name, "scenario_name")
+    validate_path_segment(policy_name, "policy_name")
+
+    replay_path = REPLAY_OUTPUT_ROOT / city_id / scenario_name / policy_name / "replay.txt"
+    if not replay_path.exists():
+        raise HTTPException(
+            status_code=404,
+            detail=f"Replay not found for {city_id}/{scenario_name}/{policy_name}. Run /run-simulations first.",
+        )
+    if max_steps > 0:
+        lines: list[str] = []
+        with open(replay_path, encoding="utf-8") as fh:
+            for raw in fh:
+                if raw.strip():
+                    lines.append(raw.rstrip("\n"))
+                    if len(lines) >= max_steps:
+                        break
+        return PlainTextResponse("\n".join(lines))
+    return FileResponse(str(replay_path), media_type="text/plain")
+
+
+@app.get("/roadnet-log/{city_id}/{scenario_name}/{policy_name}")
+def get_roadnet_log(city_id: str, scenario_name: str, policy_name: str) -> JSONResponse:
+    validate_path_segment(city_id, "city_id")
+    validate_path_segment(scenario_name, "scenario_name")
+    validate_path_segment(policy_name, "policy_name")
+
+    path = REPLAY_OUTPUT_ROOT / city_id / scenario_name / policy_name / "roadnetLogFile.json"
+    if not path.exists():
+        for p in ALL_POLICIES:
+            fallback = REPLAY_OUTPUT_ROOT / city_id / scenario_name / p / "roadnetLogFile.json"
+            if fallback.exists():
+                path = fallback
+                break
+    if not path.exists():
+        raise HTTPException(
+            status_code=404,
+            detail=f"Roadnet log not found for {city_id}/{scenario_name}.",
+        )
+    return JSONResponse(json.loads(path.read_text(encoding="utf-8")))
+
+
+@app.get("/metrics/{city_id}/{scenario_name}")
+def get_metrics(city_id: str, scenario_name: str) -> dict:
+    validate_path_segment(city_id, "city_id")
+    validate_path_segment(scenario_name, "scenario_name")
+
+    base = REPLAY_OUTPUT_ROOT / city_id / scenario_name
+    if not base.exists():
+        raise HTTPException(
+            status_code=404,
+            detail=f"No simulation results found for {city_id}/{scenario_name}.",
+        )
+
+    metrics: dict[str, Any] = {}
+    for policy_dir in sorted(base.iterdir()):
+        if not policy_dir.is_dir():
+            continue
+        metrics_path = policy_dir / "metrics.json"
+        replay_path = policy_dir / "replay.txt"
+        roadnet_log_path = policy_dir / "roadnetLogFile.json"
+        payload: dict[str, Any] = {}
+        if metrics_path.exists():
+            payload.update(json.loads(metrics_path.read_text(encoding="utf-8")))
+        if replay_path.exists():
+            payload["replay_available"] = True
+        if roadnet_log_path.exists():
+            payload["roadnet_log_available"] = True
+        if payload:
+            metrics[policy_dir.name] = payload
+
+    return {"city_id": city_id, "scenario_name": scenario_name, "metrics": metrics}
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("server.visualizer_app:app", host="0.0.0.0", port=8080, reload=False)

third_party/CityFlow/.gitignore

@@ -1,14 +1,14 @@
-data/
-build/
-build-docker/
-local/
-.vs/
-.vscode/
-.idea/
-.DS_Store
-__pycache__
-CMakeSettings.json
-cmake-build-*
-CityFlow.egg-info
-frontend/replay/*
+data/
+build/
+build-docker/
+local/
+.vs/
+.vscode/
+.idea/
+.DS_Store
+__pycache__
+CMakeSettings.json
+cmake-build-*
+CityFlow.egg-info
+frontend/replay/*
 results/replays

third_party/CityFlow/.gitmodules

@@ -1,6 +1,6 @@
-[submodule "extern/rapidjson"]
-	path = extern/rapidjson
-	url = https://github.com/cityflow-project/rapidjson.git
-[submodule "extern/pybind11"]
-	path = extern/pybind11
-	url = https://github.com/cityflow-project/pybind11.git
+[submodule "extern/rapidjson"]
+	path = extern/rapidjson
+	url = https://github.com/cityflow-project/rapidjson.git
+[submodule "extern/pybind11"]
+	path = extern/pybind11
+	url = https://github.com/cityflow-project/pybind11.git

third_party/CityFlow/CMakeLists.txt

@@ -1,76 +1,76 @@
-cmake_minimum_required(VERSION 3.5)
-project(cityflow)
-
-set(CMAKE_CXX_STANDARD "11" CACHE STRING "")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -DRAPIDJSON_HAS_STDSTRING=1")
-set(CMAKE_CXX_FLAGS_RELEASE "-O2")
-set(CMAKE_CXX_FLAGS_DEBUG "-g")
-set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-
-if(POLICY CMP0063)
-  cmake_policy(SET CMP0063 NEW)
-endif()
-
-if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE Release)
-endif(NOT CMAKE_BUILD_TYPE)
-
-include_directories(extern/milo)
-
-set(REQUIRED_SUBMODULES
-    "extern/pybind11/CMakeLists.txt"
-    "extern/rapidjson/include"
-)
-
-foreach(REQUIRED_SUBMODULE ${REQUIRED_SUBMODULES})
-    if(NOT EXISTS "${PROJECT_SOURCE_DIR}/${REQUIRED_SUBMODULE}")
-        # update submodule 
-        # https://cliutils.gitlab.io/modern-cmake/chapters/projects/submodule.html
-        find_package(Git QUIET)
-        if(GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
-        # Update submodules as needed
-            option(GIT_SUBMODULE "Check submodules during build" ON)
-            if(GIT_SUBMODULE)
-                message(STATUS "Submodule update, this may take some time...")
-                execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive
-                                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                                RESULT_VARIABLE GIT_SUBMOD_RESULT)
-                if(NOT GIT_SUBMOD_RESULT EQUAL "0")
-                    message(FATAL_ERROR "git submodule update --init failed with ${GIT_SUBMOD_RESULT}, please checkout submodules")
-                endif()
-            endif()
-        endif()
-        break()
-    else()
-        message(STATUS "Found Submodule: ${REQUIRED_SUBMODULE}")
-    endif()
-endforeach()
-
-foreach(REQUIRED_SUBMODULE ${REQUIRED_SUBMODULES})
-    if(NOT EXISTS "${PROJECT_SOURCE_DIR}/${REQUIRED_SUBMODULE}")
-        message(FATAL_ERROR "The submodule ${REQUIRED_SUBMODULE} was not downloaded! GIT_SUBMODULE was turned off or failed. Please update submodules and try again.")
-    endif()
-endforeach()
-
-add_subdirectory(extern/pybind11)
-include_directories(extern/rapidjson/include)
-
-add_subdirectory(src)
-
-# Tests
-find_package(GTest)
-if(GTEST_FOUND)
-    enable_testing()
-    add_subdirectory(tests)
-endif()
-
-if (${CMAKE_BUILD_TYPE} STREQUAL Debug)
-    add_subdirectory(tools/debug)
-endif()
-
-pybind11_add_module(${PROJECT_NAME} MODULE src/cityflow.cpp)
-target_link_libraries(${PROJECT_NAME} PRIVATE ${PROJECT_LIB_NAME})
-if(VERSION)
-    target_compile_definitions(${PROJECT_NAME} PRIVATE -DVERSION=${VERSION})
-endif()
-
+cmake_minimum_required(VERSION 3.5)
+project(cityflow)
+
+set(CMAKE_CXX_STANDARD "11" CACHE STRING "")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -DRAPIDJSON_HAS_STDSTRING=1")
+set(CMAKE_CXX_FLAGS_RELEASE "-O2")
+set(CMAKE_CXX_FLAGS_DEBUG "-g")
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+if(POLICY CMP0063)
+  cmake_policy(SET CMP0063 NEW)
+endif()
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+endif(NOT CMAKE_BUILD_TYPE)
+
+include_directories(extern/milo)
+
+set(REQUIRED_SUBMODULES
+    "extern/pybind11/CMakeLists.txt"
+    "extern/rapidjson/include"
+)
+
+foreach(REQUIRED_SUBMODULE ${REQUIRED_SUBMODULES})
+    if(NOT EXISTS "${PROJECT_SOURCE_DIR}/${REQUIRED_SUBMODULE}")
+        # update submodule 
+        # https://cliutils.gitlab.io/modern-cmake/chapters/projects/submodule.html
+        find_package(Git QUIET)
+        if(GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
+        # Update submodules as needed
+            option(GIT_SUBMODULE "Check submodules during build" ON)
+            if(GIT_SUBMODULE)
+                message(STATUS "Submodule update, this may take some time...")
+                execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive
+                                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                                RESULT_VARIABLE GIT_SUBMOD_RESULT)
+                if(NOT GIT_SUBMOD_RESULT EQUAL "0")
+                    message(FATAL_ERROR "git submodule update --init failed with ${GIT_SUBMOD_RESULT}, please checkout submodules")
+                endif()
+            endif()
+        endif()
+        break()
+    else()
+        message(STATUS "Found Submodule: ${REQUIRED_SUBMODULE}")
+    endif()
+endforeach()
+
+foreach(REQUIRED_SUBMODULE ${REQUIRED_SUBMODULES})
+    if(NOT EXISTS "${PROJECT_SOURCE_DIR}/${REQUIRED_SUBMODULE}")
+        message(FATAL_ERROR "The submodule ${REQUIRED_SUBMODULE} was not downloaded! GIT_SUBMODULE was turned off or failed. Please update submodules and try again.")
+    endif()
+endforeach()
+
+add_subdirectory(extern/pybind11)
+include_directories(extern/rapidjson/include)
+
+add_subdirectory(src)
+
+# Tests
+find_package(GTest)
+if(GTEST_FOUND)
+    enable_testing()
+    add_subdirectory(tests)
+endif()
+
+if (${CMAKE_BUILD_TYPE} STREQUAL Debug)
+    add_subdirectory(tools/debug)
+endif()
+
+pybind11_add_module(${PROJECT_NAME} MODULE src/cityflow.cpp)
+target_link_libraries(${PROJECT_NAME} PRIVATE ${PROJECT_LIB_NAME})
+if(VERSION)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE -DVERSION=${VERSION})
+endif()
+

third_party/CityFlow/Dockerfile

@@ -1,21 +1,21 @@
-FROM ubuntu:16.04
-
-# c++ dependencies
-RUN apt update && \
-    apt-get install -y build-essential cmake wget git
-
-# install Miniconda Python 3.6
-ENV LANG=C.UTF-8 LC_ALL=C.UTF-8
-ENV PATH /opt/conda/bin:$PATH
-
-RUN wget -P /tmp/ https://repo.continuum.io/miniconda/Miniconda3-4.5.4-Linux-x86_64.sh && \
-    /bin/bash /tmp/Miniconda3-4.5.4-Linux-x86_64.sh -b -p /opt/conda && \
-    rm /tmp/Miniconda3-4.5.4-Linux-x86_64.sh && \
-    ln -s /opt/conda/etc/profile.d/conda.sh /etc/profile.d/conda.sh && \
-    echo ". /opt/conda/etc/profile.d/conda.sh" >> ~/.bashrc
-
-# install cityflow
-COPY . /home/cityflow
-RUN pip install flask && \
-    cd /home/cityflow && \
+FROM ubuntu:16.04
+
+# c++ dependencies
+RUN apt update && \
+    apt-get install -y build-essential cmake wget git
+
+# install Miniconda Python 3.6
+ENV LANG=C.UTF-8 LC_ALL=C.UTF-8
+ENV PATH /opt/conda/bin:$PATH
+
+RUN wget -P /tmp/ https://repo.continuum.io/miniconda/Miniconda3-4.5.4-Linux-x86_64.sh && \
+    /bin/bash /tmp/Miniconda3-4.5.4-Linux-x86_64.sh -b -p /opt/conda && \
+    rm /tmp/Miniconda3-4.5.4-Linux-x86_64.sh && \
+    ln -s /opt/conda/etc/profile.d/conda.sh /etc/profile.d/conda.sh && \
+    echo ". /opt/conda/etc/profile.d/conda.sh" >> ~/.bashrc
+
+# install cityflow
+COPY . /home/cityflow
+RUN pip install flask && \
+    cd /home/cityflow && \
     pip install .

third_party/CityFlow/LICENSE.txt

@@ -1,201 +1,201 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
    limitations under the License.

third_party/CityFlow/README.rst

@@ -1,51 +1,51 @@
-CityFlow
-============
-
-.. image:: https://readthedocs.org/projects/cityflow/badge/?version=latest
-    :target: https://cityflow.readthedocs.io/en/latest/?badge=latest
-    :alt: Documentation Status
-
-.. image:: https://dev.azure.com/CityFlow/CityFlow/_apis/build/status/cityflow-project.CityFlow?branchName=master
-    :target: https://dev.azure.com/CityFlow/CityFlow/_build/latest?definitionId=2&branchName=master
-    :alt: Build Status
-
-CityFlow is a multi-agent reinforcement learning environment for large-scale city traffic scenario.
-
-Checkout these features!
-
-- A microscopic traffic simulator which simulates the behavior of each vehicle, providing highest level detail of traffic evolution.
-- Supports flexible definitions for road network and traffic flow
-- Provides friendly python interface for reinforcement learning
-- **Fast!** Elaborately designed data structure and simulation algorithm with multithreading. Capable of simulating city-wide traffic. See the performance comparison with SUMO [#sumo]_.
-
-.. figure:: https://user-images.githubusercontent.com/44251346/54403537-5ce16b00-470b-11e9-928d-76c8ba0ab463.png
-    :align: center
-    :alt: performance compared with SUMO
-
-    Performance comparison between CityFlow with different number of threads (1, 2, 4, 8) and SUMO. From small 1x1 grid roadnet to city-level 30x30 roadnet. Even faster when you need to interact with the simulator through python API.
-
-Screencast
-----------
-
-.. figure:: https://user-images.githubusercontent.com/44251346/62375390-c9e98600-b570-11e9-8808-e13dbe776f1e.gif
-    :align: center
-    :alt: demo
-
-Featured Research and Projects Using CityFlow
----------------------------------------------
-- `PressLight: Learning Max Pressure Control to Coordinate Traffic Signals in Arterial Network (KDD 2019) <http://personal.psu.edu/hzw77/publications/presslight-kdd19.pdf>`_
-- `CoLight: Learning Network-level Cooperation for Traffic Signal Control <https://arxiv.org/abs/1905.05717>`_
-- `Traffic Signal Control Benchmark <https://traffic-signal-control.github.io/>`_
-- `TSCC2050: A Traffic Signal Control Game by Tianrang Intelligence (in Chinese) <http://game.tscc2050.com/>`_ [#tianrang]_
-
-Links
------
-
-- `WWW 2019 Demo Paper <https://arxiv.org/abs/1905.05217>`_
-- `Home Page <http://cityflow-project.github.io/>`_
-- `Documentation and Quick Start <https://cityflow.readthedocs.io/en/latest/>`_
-- `Docker <https://hub.docker.com/r/cityflowproject/cityflow>`_
-
-
-.. [#sumo] `SUMO home page <https://sumo.dlr.de/index.html>`_
-.. [#tianrang] `Tianrang Intelligence home page <https://www.tianrang.com/>`_
+CityFlow
+============
+
+.. image:: https://readthedocs.org/projects/cityflow/badge/?version=latest
+    :target: https://cityflow.readthedocs.io/en/latest/?badge=latest
+    :alt: Documentation Status
+
+.. image:: https://dev.azure.com/CityFlow/CityFlow/_apis/build/status/cityflow-project.CityFlow?branchName=master
+    :target: https://dev.azure.com/CityFlow/CityFlow/_build/latest?definitionId=2&branchName=master
+    :alt: Build Status
+
+CityFlow is a multi-agent reinforcement learning environment for large-scale city traffic scenario.
+
+Checkout these features!
+
+- A microscopic traffic simulator which simulates the behavior of each vehicle, providing highest level detail of traffic evolution.
+- Supports flexible definitions for road network and traffic flow
+- Provides friendly python interface for reinforcement learning
+- **Fast!** Elaborately designed data structure and simulation algorithm with multithreading. Capable of simulating city-wide traffic. See the performance comparison with SUMO [#sumo]_.
+
+.. figure:: https://user-images.githubusercontent.com/44251346/54403537-5ce16b00-470b-11e9-928d-76c8ba0ab463.png
+    :align: center
+    :alt: performance compared with SUMO
+
+    Performance comparison between CityFlow with different number of threads (1, 2, 4, 8) and SUMO. From small 1x1 grid roadnet to city-level 30x30 roadnet. Even faster when you need to interact with the simulator through python API.
+
+Screencast
+----------
+
+.. figure:: https://user-images.githubusercontent.com/44251346/62375390-c9e98600-b570-11e9-8808-e13dbe776f1e.gif
+    :align: center
+    :alt: demo
+
+Featured Research and Projects Using CityFlow
+---------------------------------------------
+- `PressLight: Learning Max Pressure Control to Coordinate Traffic Signals in Arterial Network (KDD 2019) <http://personal.psu.edu/hzw77/publications/presslight-kdd19.pdf>`_
+- `CoLight: Learning Network-level Cooperation for Traffic Signal Control <https://arxiv.org/abs/1905.05717>`_
+- `Traffic Signal Control Benchmark <https://traffic-signal-control.github.io/>`_
+- `TSCC2050: A Traffic Signal Control Game by Tianrang Intelligence (in Chinese) <http://game.tscc2050.com/>`_ [#tianrang]_
+
+Links
+-----
+
+- `WWW 2019 Demo Paper <https://arxiv.org/abs/1905.05217>`_
+- `Home Page <http://cityflow-project.github.io/>`_
+- `Documentation and Quick Start <https://cityflow.readthedocs.io/en/latest/>`_
+- `Docker <https://hub.docker.com/r/cityflowproject/cityflow>`_
+
+
+.. [#sumo] `SUMO home page <https://sumo.dlr.de/index.html>`_
+.. [#tianrang] `Tianrang Intelligence home page <https://www.tianrang.com/>`_

third_party/CityFlow/docs/Makefile

@@ -1,20 +1,20 @@
-# Minimal makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line.
-SPHINXOPTS    =
-SPHINXBUILD   = sphinx-build
-SPHINXPROJ    = CityFlow
-SOURCEDIR     = source
-BUILDDIR      = build
-
-# Put it first so that "make" without argument is like "make help".
-help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
-
-.PHONY: help Makefile
-
-# Catch-all target: route all unknown targets to Sphinx using the new
-# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: Makefile
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SPHINXPROJ    = CityFlow
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

third_party/CityFlow/docs/make.bat

@@ -1,36 +1,36 @@
-@ECHO OFF
-
-pushd %~dp0
-
-REM Command file for Sphinx documentation
-
-if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=sphinx-build
-)
-set SOURCEDIR=source
-set BUILDDIR=build
-set SPHINXPROJ=CityFlow
-
-if "%1" == "" goto help
-
-%SPHINXBUILD% >NUL 2>NUL
-if errorlevel 9009 (
-	echo.
-	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
-	echo.installed, then set the SPHINXBUILD environment variable to point
-	echo.to the full path of the 'sphinx-build' executable. Alternatively you
-	echo.may add the Sphinx directory to PATH.
-	echo.
-	echo.If you don't have Sphinx installed, grab it from
-	echo.http://sphinx-doc.org/
-	exit /b 1
-)
-
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
-goto end
-
-:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
-
-:end
-popd
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+set SPHINXPROJ=CityFlow
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+
+:end
+popd

third_party/CityFlow/docs/source/conf.py

@@ -1,155 +1,155 @@
-# -*- coding: utf-8 -*-
-#
-# Configuration file for the Sphinx documentation builder.
-#
-# This file does only contain a selection of the most common options. For a
-# full list see the documentation:
-# http://www.sphinx-doc.org/en/master/config
-
-# -- Path setup --------------------------------------------------------------
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-# import os
-# import sys
-# sys.path.insert(0, os.path.abspath('.'))
-
-
-# -- Project information -----------------------------------------------------
-
-project = 'CityFlow'
-copyright = '2019, CityFlow'
-author = 'Huichu Zhang'
-
-# The short X.Y version
-version = ''
-# The full version, including alpha/beta/rc tags
-release = '0.1'
-
-
-# -- General configuration ---------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#
-# needs_sphinx = '1.0'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
-]
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-#
-# source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
-
-# The master toctree document.
-master_doc = 'index'
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = None
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This pattern also affects html_static_path and html_extra_path .
-exclude_patterns = []
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-
-# -- Options for HTML output -------------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-html_theme = 'sphinx_rtd_theme'
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#
-# html_theme_options = {}
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-
-# Custom sidebar templates, must be a dictionary that maps document names
-# to template names.
-#
-# The default sidebars (for documents that don't match any pattern) are
-# defined by theme itself.  Builtin themes are using these templates by
-# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
-# 'searchbox.html']``.
-#
-# html_sidebars = {}
-
-
-# -- Options for HTMLHelp output ---------------------------------------------
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'CityFlowdoc'
-
-
-# -- Options for LaTeX output ------------------------------------------------
-
-latex_elements = {
-    # The paper size ('letterpaper' or 'a4paper').
-    #
-    # 'papersize': 'letterpaper',
-
-    # The font size ('10pt', '11pt' or '12pt').
-    #
-    # 'pointsize': '10pt',
-
-    # Additional stuff for the LaTeX preamble.
-    #
-    # 'preamble': '',
-
-    # Latex figure (float) alignment
-    #
-    # 'figure_align': 'htbp',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, documentclass [howto, manual, or own class]).
-latex_documents = [
-    (master_doc, 'CityFlow.tex', 'CityFlow Documentation',
-     'Huichu Zhang', 'manual'),
-]
-
-
-# -- Options for manual page output ------------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
-    (master_doc, 'cityflow', 'CityFlow Documentation',
-     [author], 1)
-]
-
-
-# -- Options for Texinfo output ----------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-texinfo_documents = [
-    (master_doc, 'CityFlow', 'CityFlow Documentation',
-     author, 'CityFlow', 'One line description of project.',
-     'Miscellaneous'),
+# -*- coding: utf-8 -*-
+#
+# Configuration file for the Sphinx documentation builder.
+#
+# This file does only contain a selection of the most common options. For a
+# full list see the documentation:
+# http://www.sphinx-doc.org/en/master/config
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+
+# -- Project information -----------------------------------------------------
+
+project = 'CityFlow'
+copyright = '2019, CityFlow'
+author = 'Huichu Zhang'
+
+# The short X.Y version
+version = ''
+# The full version, including alpha/beta/rc tags
+release = '0.1'
+
+
+# -- General configuration ---------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The master toctree document.
+master_doc = 'index'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path .
+exclude_patterns = []
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'sphinx_rtd_theme'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#
+# html_theme_options = {}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+# Custom sidebar templates, must be a dictionary that maps document names
+# to template names.
+#
+# The default sidebars (for documents that don't match any pattern) are
+# defined by theme itself.  Builtin themes are using these templates by
+# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
+# 'searchbox.html']``.
+#
+# html_sidebars = {}
+
+
+# -- Options for HTMLHelp output ---------------------------------------------
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'CityFlowdoc'
+
+
+# -- Options for LaTeX output ------------------------------------------------
+
+latex_elements = {
+    # The paper size ('letterpaper' or 'a4paper').
+    #
+    # 'papersize': 'letterpaper',
+
+    # The font size ('10pt', '11pt' or '12pt').
+    #
+    # 'pointsize': '10pt',
+
+    # Additional stuff for the LaTeX preamble.
+    #
+    # 'preamble': '',
+
+    # Latex figure (float) alignment
+    #
+    # 'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (master_doc, 'CityFlow.tex', 'CityFlow Documentation',
+     'Huichu Zhang', 'manual'),
+]
+
+
+# -- Options for manual page output ------------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc, 'cityflow', 'CityFlow Documentation',
+     [author], 1)
+]
+
+
+# -- Options for Texinfo output ----------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (master_doc, 'CityFlow', 'CityFlow Documentation',
+     author, 'CityFlow', 'One line description of project.',
+     'Miscellaneous'),
 ]

third_party/CityFlow/docs/source/flow.rst

@@ -1,23 +1,23 @@
-.. _flow:
-
-Flow File Format
-===================
-    
-Flow file defines the traffic flow. Each flow contains following field:
-
-- ``vehicle``: defines the parameter of vehicle.
-    - length: length of the vehicle
-    - width: width of the vehicle
-    - maxPosAcc: maximum acceleration (in m/s)
-    - maxNegAcc: maximum deceleration (in m/s)
-    - usualPosAcc: usual acceleration (in m/s)
-    - usualNegAcc: usual deceleration (in m/s)
-    - minGap: minimum acceptable gap with leading vehicle (in meter)
-    - maxSpeed: maximum cruising speed (in m/s)
-    - headwayTime: desired headway time (in seconds) with leading vehicle, keep *current speed \* headwayTime* gap.
-- ``route``: defines the route, all vehicles of this flow will follow the route. Specify the source and the destination, optionally some anchor points and the router will connect them with shortest paths automatically.
-- ``interval``: defines the interval of consecutive vehicles (in seconds). If the interval is too small, vehicles may not be able to enter the road due to blockage, it will be held and let go once there are enough space.
-- ``startTime``, ``endTime``: Flow will generate vehicles between time [startTime, endTime] (in seconds), including ``startTime`` and ``endTime``.
-
-.. note::
-  Runnable sample flow files can be found in ``examples`` folder.
+.. _flow:
+
+Flow File Format
+===================
+    
+Flow file defines the traffic flow. Each flow contains following field:
+
+- ``vehicle``: defines the parameter of vehicle.
+    - length: length of the vehicle
+    - width: width of the vehicle
+    - maxPosAcc: maximum acceleration (in m/s)
+    - maxNegAcc: maximum deceleration (in m/s)
+    - usualPosAcc: usual acceleration (in m/s)
+    - usualNegAcc: usual deceleration (in m/s)
+    - minGap: minimum acceptable gap with leading vehicle (in meter)
+    - maxSpeed: maximum cruising speed (in m/s)
+    - headwayTime: desired headway time (in seconds) with leading vehicle, keep *current speed \* headwayTime* gap.
+- ``route``: defines the route, all vehicles of this flow will follow the route. Specify the source and the destination, optionally some anchor points and the router will connect them with shortest paths automatically.
+- ``interval``: defines the interval of consecutive vehicles (in seconds). If the interval is too small, vehicles may not be able to enter the road due to blockage, it will be held and let go once there are enough space.
+- ``startTime``, ``endTime``: Flow will generate vehicles between time [startTime, endTime] (in seconds), including ``startTime`` and ``endTime``.
+
+.. note::
+  Runnable sample flow files can be found in ``examples`` folder.

third_party/CityFlow/docs/source/index.rst

@@ -1,18 +1,18 @@
-.. CityFlow documentation master file, created by
-   sphinx-quickstart on Wed Mar 13 21:59:27 2019.
-   You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
-
-Welcome to CityFlow's documentation!
-====================================
-
-.. toctree::
-    :maxdepth: 2
-    :caption: Contents:
-
-    introduction
-    install
-    start
-    roadnet
-    flow
-    replay
+.. CityFlow documentation master file, created by
+   sphinx-quickstart on Wed Mar 13 21:59:27 2019.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to CityFlow's documentation!
+====================================
+
+.. toctree::
+    :maxdepth: 2
+    :caption: Contents:
+
+    introduction
+    install
+    start
+    roadnet
+    flow
+    replay

third_party/CityFlow/docs/source/install.rst

@@ -1,66 +1,66 @@
-.. _install:
-
-Installation Guide
-==================
-
-Docker
-------
-
-The easiest way to use CityFlow is via docker.
-
-.. code-block:: shell
-    
-    docker pull cityflowproject/cityflow:latest
-
-This will create docker image ``cityflow:latest``.
-
-.. code-block:: shell
-    
-    docker run -it cityflowproject/cityflow:latest
-
-Create and start a container, CityFlow is out-of-the-box along with miniconda with python3.6.
-
-.. code-block:: python
-    
-    import cityflow
-    eng = cityflow.Engine
-
-Build From Source
------------------
-
-If you want to get nightly version of CityFlow or running on native system, you can build CityFlow from source. Currently, we only support building on Unix systems. This guide is based on Ubuntu 16.04.
-
-CityFlow has little dependencies, so building from source is not scary.
-
-1. Check that you have python 3 installed. Other version of python might work, however, we only tested on python with version >= 3.5.
-
-
-2. Install cpp dependencies
-
-.. code-block:: shell
-    
-    sudo apt update && sudo apt install -y build-essential cmake
-
-3. Clone CityFlow project from github.
-
-.. code-block:: shell
-    
-    git clone https://github.com/cityflow-project/CityFlow.git
-    
-4. Go to CityFlow project's root directory and run
-
-.. code-block:: shell
-    
-    pip install .
-
-5. Wait for installation to complete and CityFlow should be successfully installed.
-
-.. code-block:: python
-    
-    import cityflow
-    eng = cityflow.Engine
-
-For Windows Users
-------------------
-
-For Windows users, it is recommended to run CityFlow under Windows Subsystem for Linux (WSL) or use docker.
+.. _install:
+
+Installation Guide
+==================
+
+Docker
+------
+
+The easiest way to use CityFlow is via docker.
+
+.. code-block:: shell
+    
+    docker pull cityflowproject/cityflow:latest
+
+This will create docker image ``cityflow:latest``.
+
+.. code-block:: shell
+    
+    docker run -it cityflowproject/cityflow:latest
+
+Create and start a container, CityFlow is out-of-the-box along with miniconda with python3.6.
+
+.. code-block:: python
+    
+    import cityflow
+    eng = cityflow.Engine
+
+Build From Source
+-----------------
+
+If you want to get nightly version of CityFlow or running on native system, you can build CityFlow from source. Currently, we only support building on Unix systems. This guide is based on Ubuntu 16.04.
+
+CityFlow has little dependencies, so building from source is not scary.
+
+1. Check that you have python 3 installed. Other version of python might work, however, we only tested on python with version >= 3.5.
+
+
+2. Install cpp dependencies
+
+.. code-block:: shell
+    
+    sudo apt update && sudo apt install -y build-essential cmake
+
+3. Clone CityFlow project from github.
+
+.. code-block:: shell
+    
+    git clone https://github.com/cityflow-project/CityFlow.git
+    
+4. Go to CityFlow project's root directory and run
+
+.. code-block:: shell
+    
+    pip install .
+
+5. Wait for installation to complete and CityFlow should be successfully installed.
+
+.. code-block:: python
+    
+    import cityflow
+    eng = cityflow.Engine
+
+For Windows Users
+------------------
+
+For Windows users, it is recommended to run CityFlow under Windows Subsystem for Linux (WSL) or use docker.

third_party/CityFlow/examples/config.json

@@ -1,12 +1,12 @@
-{
-	"interval": 1.0,
-	"seed": 0,
-	"dir": "CityFlow/examples/",
-	"roadnetFile": "roadnet.json", 
-	"flowFile": "flow.json", 
-	"rlTrafficLight": false,
-	"laneChange": false,
-	"saveReplay": true,
-	"roadnetLogFile": "replay_roadnet.json", 
-	"replayLogFile": "replay.txt"
+{
+	"interval": 1.0,
+	"seed": 0,
+	"dir": "CityFlow/examples/",
+	"roadnetFile": "roadnet.json", 
+	"flowFile": "flow.json", 
+	"rlTrafficLight": false,
+	"laneChange": false,
+	"saveReplay": true,
+	"roadnetLogFile": "replay_roadnet.json", 
+	"replayLogFile": "replay.txt"
 }

third_party/CityFlow/examples/flow.json

@@ -1,242 +1,242 @@
-[
-  {
-    "vehicle": {
-      "length": 5.0,
-      "width": 2.0,
-      "maxPosAcc": 2.0,
-      "maxNegAcc": 4.5,
-      "usualPosAcc": 2.0,
-      "usualNegAcc": 4.5,
-      "minGap": 2.5,
-      "maxSpeed": 16.67,
-      "headwayTime": 1.5
-    },
-    "route": [
-      "road_0_1_0",
-      "road_1_1_0"
-    ],
-    "interval": 5.0,
-    "startTime": 0,
-    "endTime": -1
-  },
-  {
-    "vehicle": {
-      "length": 5.0,
-      "width": 2.0,
-      "maxPosAcc": 2.0,
-      "maxNegAcc": 4.5,
-      "usualPosAcc": 2.0,
-      "usualNegAcc": 4.5,
-      "minGap": 2.5,
-      "maxSpeed": 16.67,
-      "headwayTime": 1.5
-    },
-    "route": [
-      "road_2_1_2",
-      "road_1_1_2"
-    ],
-    "interval": 5.0,
-    "startTime": 0,
-    "endTime": -1
-  },
-  {
-    "vehicle": {
-      "length": 5.0,
-      "width": 2.0,
-      "maxPosAcc": 2.0,
-      "maxNegAcc": 4.5,
-      "usualPosAcc": 2.0,
-      "usualNegAcc": 4.5,
-      "minGap": 2.5,
-      "maxSpeed": 16.67,
-      "headwayTime": 1.5
-    },
-    "route": [
-      "road_1_0_1",
-      "road_1_1_1"
-    ],
-    "interval": 5.0,
-    "startTime": 0,
-    "endTime": -1
-  },
-  {
-    "vehicle": {
-      "length": 5.0,
-      "width": 2.0,
-      "maxPosAcc": 2.0,
-      "maxNegAcc": 4.5,
-      "usualPosAcc": 2.0,
-      "usualNegAcc": 4.5,
-      "minGap": 2.5,
-      "maxSpeed": 16.67,
-      "headwayTime": 1.5
-    },
-    "route": [
-      "road_1_2_3",
-      "road_1_1_3"
-    ],
-    "interval": 5.0,
-    "startTime": 0,
-    "endTime": -1
-  },
-  {
-    "vehicle": {
-      "length": 5.0,
-      "width": 2.0,
-      "maxPosAcc": 2.0,
-      "maxNegAcc": 4.5,
-      "usualPosAcc": 2.0,
-      "usualNegAcc": 4.5,
-      "minGap": 2.5,
-      "maxSpeed": 16.67,
-      "headwayTime": 1.5
-    },
-    "route": [
-      "road_1_0_1",
-      "road_1_1_0"
-    ],
-    "interval": 5.0,
-    "startTime": 0,
-    "endTime": -1
-  },
-  {
-    "vehicle": {
-      "length": 5.0,
-      "width": 2.0,
-      "maxPosAcc": 2.0,
-      "maxNegAcc": 4.5,
-      "usualPosAcc": 2.0,
-      "usualNegAcc": 4.5,
-      "minGap": 2.5,
-      "maxSpeed": 16.67,
-      "headwayTime": 1.5
-    },
-    "route": [
-      "road_0_1_0",
-      "road_1_1_1"
-    ],
-    "interval": 5.0,
-    "startTime": 0,
-    "endTime": -1
-  },
-  {
-    "vehicle": {
-      "length": 5.0,
-      "width": 2.0,
-      "maxPosAcc": 2.0,
-      "maxNegAcc": 4.5,
-      "usualPosAcc": 2.0,
-      "usualNegAcc": 4.5,
-      "minGap": 2.5,
-      "maxSpeed": 16.67,
-      "headwayTime": 1.5
-    },
-    "route": [
-      "road_2_1_2",
-      "road_1_1_3"
-    ],
-    "interval": 5.0,
-    "startTime": 0,
-    "endTime": -1
-  },
-  {
-    "vehicle": {
-      "length": 5.0,
-      "width": 2.0,
-      "maxPosAcc": 2.0,
-      "maxNegAcc": 4.5,
-      "usualPosAcc": 2.0,
-      "usualNegAcc": 4.5,
-      "minGap": 2.5,
-      "maxSpeed": 16.67,
-      "headwayTime": 1.5
-    },
-    "route": [
-      "road_1_2_3",
-      "road_1_1_2"
-    ],
-    "interval": 5.0,
-    "startTime": 0,
-    "endTime": -1
-  },
-  {
-    "vehicle": {
-      "length": 5.0,
-      "width": 2.0,
-      "maxPosAcc": 2.0,
-      "maxNegAcc": 4.5,
-      "usualPosAcc": 2.0,
-      "usualNegAcc": 4.5,
-      "minGap": 2.5,
-      "maxSpeed": 16.67,
-      "headwayTime": 1.5
-    },
-    "route": [
-      "road_0_1_0",
-      "road_1_1_3"
-    ],
-    "interval": 5.0,
-    "startTime": 0,
-    "endTime": -1
-  },
-  {
-    "vehicle": {
-      "length": 5.0,
-      "width": 2.0,
-      "maxPosAcc": 2.0,
-      "maxNegAcc": 4.5,
-      "usualPosAcc": 2.0,
-      "usualNegAcc": 4.5,
-      "minGap": 2.5,
-      "maxSpeed": 16.67,
-      "headwayTime": 1.5
-    },
-    "route": [
-      "road_1_2_3",
-      "road_1_1_0"
-    ],
-    "interval": 5.0,
-    "startTime": 0,
-    "endTime": -1
-  },
-  {
-    "vehicle": {
-      "length": 5.0,
-      "width": 2.0,
-      "maxPosAcc": 2.0,
-      "maxNegAcc": 4.5,
-      "usualPosAcc": 2.0,
-      "usualNegAcc": 4.5,
-      "minGap": 2.5,
-      "maxSpeed": 16.67,
-      "headwayTime": 1.5
-    },
-    "route": [
-      "road_2_1_2",
-      "road_1_1_1"
-    ],
-    "interval": 5.0,
-    "startTime": 0,
-    "endTime": -1
-  },
-  {
-    "vehicle": {
-      "length": 5.0,
-      "width": 2.0,
-      "maxPosAcc": 2.0,
-      "maxNegAcc": 4.5,
-      "usualPosAcc": 2.0,
-      "usualNegAcc": 4.5,
-      "minGap": 2.5,
-      "maxSpeed": 16.67,
-      "headwayTime": 1.5
-    },
-    "route": [
-      "road_1_0_1",
-      "road_1_1_2"
-    ],
-    "interval": 5.0,
-    "startTime": 0,
-    "endTime": -1
-  }
+[
+  {
+    "vehicle": {
+      "length": 5.0,
+      "width": 2.0,
+      "maxPosAcc": 2.0,
+      "maxNegAcc": 4.5,
+      "usualPosAcc": 2.0,
+      "usualNegAcc": 4.5,
+      "minGap": 2.5,
+      "maxSpeed": 16.67,
+      "headwayTime": 1.5
+    },
+    "route": [
+      "road_0_1_0",
+      "road_1_1_0"
+    ],
+    "interval": 5.0,
+    "startTime": 0,
+    "endTime": -1
+  },
+  {
+    "vehicle": {
+      "length": 5.0,
+      "width": 2.0,
+      "maxPosAcc": 2.0,
+      "maxNegAcc": 4.5,
+      "usualPosAcc": 2.0,
+      "usualNegAcc": 4.5,
+      "minGap": 2.5,
+      "maxSpeed": 16.67,
+      "headwayTime": 1.5
+    },
+    "route": [
+      "road_2_1_2",
+      "road_1_1_2"
+    ],
+    "interval": 5.0,
+    "startTime": 0,
+    "endTime": -1
+  },
+  {
+    "vehicle": {
+      "length": 5.0,
+      "width": 2.0,
+      "maxPosAcc": 2.0,
+      "maxNegAcc": 4.5,
+      "usualPosAcc": 2.0,
+      "usualNegAcc": 4.5,
+      "minGap": 2.5,
+      "maxSpeed": 16.67,
+      "headwayTime": 1.5
+    },
+    "route": [
+      "road_1_0_1",
+      "road_1_1_1"
+    ],
+    "interval": 5.0,
+    "startTime": 0,
+    "endTime": -1
+  },
+  {
+    "vehicle": {
+      "length": 5.0,
+      "width": 2.0,
+      "maxPosAcc": 2.0,
+      "maxNegAcc": 4.5,
+      "usualPosAcc": 2.0,
+      "usualNegAcc": 4.5,
+      "minGap": 2.5,
+      "maxSpeed": 16.67,
+      "headwayTime": 1.5
+    },
+    "route": [
+      "road_1_2_3",
+      "road_1_1_3"
+    ],
+    "interval": 5.0,
+    "startTime": 0,
+    "endTime": -1
+  },
+  {
+    "vehicle": {
+      "length": 5.0,
+      "width": 2.0,
+      "maxPosAcc": 2.0,
+      "maxNegAcc": 4.5,
+      "usualPosAcc": 2.0,
+      "usualNegAcc": 4.5,
+      "minGap": 2.5,
+      "maxSpeed": 16.67,
+      "headwayTime": 1.5
+    },
+    "route": [
+      "road_1_0_1",
+      "road_1_1_0"
+    ],
+    "interval": 5.0,
+    "startTime": 0,
+    "endTime": -1
+  },
+  {
+    "vehicle": {
+      "length": 5.0,
+      "width": 2.0,
+      "maxPosAcc": 2.0,
+      "maxNegAcc": 4.5,
+      "usualPosAcc": 2.0,
+      "usualNegAcc": 4.5,
+      "minGap": 2.5,
+      "maxSpeed": 16.67,
+      "headwayTime": 1.5
+    },
+    "route": [
+      "road_0_1_0",
+      "road_1_1_1"
+    ],
+    "interval": 5.0,
+    "startTime": 0,
+    "endTime": -1
+  },
+  {
+    "vehicle": {
+      "length": 5.0,
+      "width": 2.0,
+      "maxPosAcc": 2.0,
+      "maxNegAcc": 4.5,
+      "usualPosAcc": 2.0,
+      "usualNegAcc": 4.5,
+      "minGap": 2.5,
+      "maxSpeed": 16.67,
+      "headwayTime": 1.5
+    },
+    "route": [
+      "road_2_1_2",
+      "road_1_1_3"
+    ],
+    "interval": 5.0,
+    "startTime": 0,
+    "endTime": -1
+  },
+  {
+    "vehicle": {
+      "length": 5.0,
+      "width": 2.0,
+      "maxPosAcc": 2.0,
+      "maxNegAcc": 4.5,
+      "usualPosAcc": 2.0,
+      "usualNegAcc": 4.5,
+      "minGap": 2.5,
+      "maxSpeed": 16.67,
+      "headwayTime": 1.5
+    },
+    "route": [
+      "road_1_2_3",
+      "road_1_1_2"
+    ],
+    "interval": 5.0,
+    "startTime": 0,
+    "endTime": -1
+  },
+  {
+    "vehicle": {
+      "length": 5.0,
+      "width": 2.0,
+      "maxPosAcc": 2.0,
+      "maxNegAcc": 4.5,
+      "usualPosAcc": 2.0,
+      "usualNegAcc": 4.5,
+      "minGap": 2.5,
+      "maxSpeed": 16.67,
+      "headwayTime": 1.5
+    },
+    "route": [
+      "road_0_1_0",
+      "road_1_1_3"
+    ],
+    "interval": 5.0,
+    "startTime": 0,
+    "endTime": -1
+  },
+  {
+    "vehicle": {
+      "length": 5.0,
+      "width": 2.0,
+      "maxPosAcc": 2.0,
+      "maxNegAcc": 4.5,
+      "usualPosAcc": 2.0,
+      "usualNegAcc": 4.5,
+      "minGap": 2.5,
+      "maxSpeed": 16.67,
+      "headwayTime": 1.5
+    },
+    "route": [
+      "road_1_2_3",
+      "road_1_1_0"
+    ],
+    "interval": 5.0,
+    "startTime": 0,
+    "endTime": -1
+  },
+  {
+    "vehicle": {
+      "length": 5.0,
+      "width": 2.0,
+      "maxPosAcc": 2.0,
+      "maxNegAcc": 4.5,
+      "usualPosAcc": 2.0,
+      "usualNegAcc": 4.5,
+      "minGap": 2.5,
+      "maxSpeed": 16.67,
+      "headwayTime": 1.5
+    },
+    "route": [
+      "road_2_1_2",
+      "road_1_1_1"
+    ],
+    "interval": 5.0,
+    "startTime": 0,
+    "endTime": -1
+  },
+  {
+    "vehicle": {
+      "length": 5.0,
+      "width": 2.0,
+      "maxPosAcc": 2.0,
+      "maxNegAcc": 4.5,
+      "usualPosAcc": 2.0,
+      "usualNegAcc": 4.5,
+      "minGap": 2.5,
+      "maxSpeed": 16.67,
+      "headwayTime": 1.5
+    },
+    "route": [
+      "road_1_0_1",
+      "road_1_1_2"
+    ],
+    "interval": 5.0,
+    "startTime": 0,
+    "endTime": -1
+  }
 ]

third_party/CityFlow/frontend/Point.js

@@ -1,57 +1,57 @@
-class Point {
-    constructor(x, y) {
-        if (arguments.length == 1) {
-            this.x = x[0];
-            this.y = x[1];
-        } else if (arguments.length == 2) {
-            this.x = x;
-            this.y = y;
-        }   
-    }
-    
-    getLength() {
-        return Math.sqrt(this.x*this.x + this.y*this.y);
-    }
-    
-    getAngle() {
-        return this.getAngleInRadians() * 180 / Math.PI;
-    }
-
-    getAngleInRadians() {
-        return Math.atan2(this.y, this.x);
-    }
-
-    add(point) {
-        return new Point(this.x + point.x, this.y + point.y)
-    }
-
-    directTo(point) {
-        let x = point.x - this.x;
-        let y = point.y - this.y;
-        let length = Math.sqrt(x*x + y*y);
-        let scale = length !== 0 ? 1 / length : 0;
-        return new Point(x * scale, y * scale);
-    }
-
-    distanceTo(point) {
-        let x = point.x - this.x;
-        let y = point.y - this.y;
-        return Math.sqrt(x*x + y*y);
-    }
-
-    moveAlong(direct, length) {
-        return new Point(this.x + direct.x * length, this.y + direct.y * length);
-    }
-
-    moveAlongDirectTo(point, length) {
-        let direct = this.directTo(point);
-        return new Point(this.x + direct.x * length, this.y + direct.y * length);
-    }
-
-    rotate(angle) {
-        angle = angle * Math.PI / 180;
-        let sin = Math.sin(angle);
-        let cos = Math.cos(angle);
-        return new Point(this.x * cos - this.y * sin, this.x * sin + this.y * cos);
-    }
+class Point {
+    constructor(x, y) {
+        if (arguments.length == 1) {
+            this.x = x[0];
+            this.y = x[1];
+        } else if (arguments.length == 2) {
+            this.x = x;
+            this.y = y;
+        }   
+    }
+    
+    getLength() {
+        return Math.sqrt(this.x*this.x + this.y*this.y);
+    }
+    
+    getAngle() {
+        return this.getAngleInRadians() * 180 / Math.PI;
+    }
+
+    getAngleInRadians() {
+        return Math.atan2(this.y, this.x);
+    }
+
+    add(point) {
+        return new Point(this.x + point.x, this.y + point.y)
+    }
+
+    directTo(point) {
+        let x = point.x - this.x;
+        let y = point.y - this.y;
+        let length = Math.sqrt(x*x + y*y);
+        let scale = length !== 0 ? 1 / length : 0;
+        return new Point(x * scale, y * scale);
+    }
+
+    distanceTo(point) {
+        let x = point.x - this.x;
+        let y = point.y - this.y;
+        return Math.sqrt(x*x + y*y);
+    }
+
+    moveAlong(direct, length) {
+        return new Point(this.x + direct.x * length, this.y + direct.y * length);
+    }
+
+    moveAlongDirectTo(point, length) {
+        let direct = this.directTo(point);
+        return new Point(this.x + direct.x * length, this.y + direct.y * length);
+    }
+
+    rotate(angle) {
+        angle = angle * Math.PI / 180;
+        let sin = Math.sin(angle);
+        let cos = Math.cos(angle);
+        return new Point(this.x * cos - this.y * sin, this.x * sin + this.y * cos);
+    }
 }

third_party/CityFlow/frontend/README.md

@@ -1,7 +1,7 @@
-# CityFlow Frontend Tool
-
-Open `index.html` to view replay.
-
-Run `python download_replay.py` to download example replay files.
-
+# CityFlow Frontend Tool
+
+Open `index.html` to view replay.
+
+Run `python download_replay.py` to download example replay files.
+
 Checkout [Document](https://cityflow.readthedocs.io/en/latest/replay.html) for more instructions.

third_party/CityFlow/frontend/download_replay.py

@@ -1,19 +1,19 @@
-import os
-from urllib.request import urlretrieve
-
-files = ["replay.txt", "roadnet.json"]
-repo_url = "https://github.com/cityflow-project/data/raw/master/frontend/replay/"
-
-folder = "replay"
-if __name__ == '__main__':
-    if not (os.path.exists(folder) and os.path.isdir(folder)):
-        os.mkdir(folder)
-        print("make %s folder, done!" % folder)
-    
-    for file_name in files:
-        if os.path.exists(folder + "/" + file_name):
-            print(file_name + " found.")
-        else:
-            print("retrieving %s from cityflow-project/data/frontend/replay" % file_name)
-            urlretrieve(repo_url + file_name, folder + "/" + file_name)
+import os
+from urllib.request import urlretrieve
+
+files = ["replay.txt", "roadnet.json"]
+repo_url = "https://github.com/cityflow-project/data/raw/master/frontend/replay/"
+
+folder = "replay"
+if __name__ == '__main__':
+    if not (os.path.exists(folder) and os.path.isdir(folder)):
+        os.mkdir(folder)
+        print("make %s folder, done!" % folder)
+    
+    for file_name in files:
+        if os.path.exists(folder + "/" + file_name):
+            print(file_name + " found.")
+        else:
+            print("retrieving %s from cityflow-project/data/frontend/replay" % file_name)
+            urlretrieve(repo_url + file_name, folder + "/" + file_name)
             print("done!")

third_party/CityFlow/frontend/index.html

@@ -1,136 +1,136 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8" />
-  <title>Traffic Visualizer</title>
-  <script src="https://cdnjs.cloudflare.com/ajax/libs/pixi.js/4.8.2/pixi.min.js"></script>
-  <script src="https://cdn.jsdelivr.net/npm/pixi-viewport@4.2.3/dist/viewport.min.js"></script>
-  <link rel="stylesheet" href="/static/style_multi.css?v=20260308h">
-  <script src="/static/Point.js?v=20260308h"></script>
-  <style>
-    @keyframes fadeInUp {
-      from { opacity: 0; transform: translateY(8px); }
-      to   { opacity: 1; transform: translateY(0); }
-    }
-  </style>
-</head>
-<body>
-
-<!-- ── Left sidebar ──────────────────────────────────────── -->
-<aside id="sidebar">
-  <div>
-    <h1>Traffic Visualizer</h1>
-    <p class="subtitle">Multi-policy comparison dashboard</p>
-  </div>
-
-  <!-- 1. Roadnet upload -->
-  <div class="sidebar-section">
-    <h3>1. Upload Roadnet</h3>
-    <div id="roadnet-drop-zone">
-      <span class="drop-icon">&#x1F5FA;</span>
-      <div>Drop <strong>roadnet.json</strong> here</div>
-      <div style="font-size:11px; margin-top:4px; color:#555">or click to browse</div>
-      <div class="drop-filename"></div>
-    </div>
-    <input type="file" id="roadnet-file-input" accept=".json" />
-  </div>
-
-  <!-- 2. City / Scenario -->
-  <div class="sidebar-section">
-    <h3>2. Select Scenario</h3>
-    <div class="picker-row">
-      <label for="city-select">City</label>
-      <select id="city-select">
-        <option value="">-- loading --</option>
-      </select>
-    </div>
-    <div class="picker-row" style="margin-top:8px;">
-      <label for="scenario-select">Scenario</label>
-      <select id="scenario-select" disabled>
-        <option value="">-- select city first --</option>
-      </select>
-    </div>
-  </div>
-
-  <!-- 3. Policies -->
-  <div class="sidebar-section">
-    <h3>3. Policies</h3>
-    <div id="policy-list" class="policy-list"></div>
-  </div>
-
-  <!-- 4. View mode -->
-  <div class="sidebar-section">
-    <h3>4. View Mode</h3>
-    <div class="view-mode-row">
-      <button class="view-mode-btn active" data-panels="1">1</button>
-      <button class="view-mode-btn" data-panels="2">2</button>
-      <button class="view-mode-btn" data-panels="3">3</button>
-      <button class="view-mode-btn" data-panels="6">All 6</button>
-    </div>
-  </div>
-
-  <!-- Run -->
-  <button id="run-btn">Run Simulations</button>
-  <label class="force-rerun-row">
-    <input type="checkbox" id="force-rerun-checkbox" />
-    <span>Force rerun (ignore cache)</span>
-  </label>
-
-  <!-- Progress -->
-  <div class="sidebar-section" id="progress-section" style="display:none;"></div>
-
-  <!-- Debug log -->
-  <div class="sidebar-section" id="debug-log-section">
-    <h3>Debug Log</h3>
-    <div id="debug-log" class="debug-log"></div>
-  </div>
-
-  <!-- Recent runs -->
-  <div class="sidebar-section" id="recent-runs-section">
-    <h3>Recent Runs</h3>
-    <div id="recent-runs-list" class="recent-runs-list">
-      <div class="recent-run-empty">No saved runs yet.</div>
-    </div>
-  </div>
-</aside>
-
-<div id="sidebar-resize-handle"></div>
-
-<!-- ── Main area ─────────────────────────────────────────── -->
-<div id="main">
-
-  <!-- Playback toolbar -->
-  <div id="playback-bar">
-    <button id="pause-btn">Pause</button>
-    <button id="speed-down">&#8722;</button>
-    <input type="range" id="scrubber" min="0" max="0" value="0" />
-    <button id="speed-up">&#43;</button>
-    <span id="speed-label">0.5x</span>
-    <span id="step-display">0 / 0</span>
-  </div>
-
-  <div id="summary-bar">
-    <div class="summary-empty">Run a simulation to compare policy metrics.</div>
-  </div>
-
-  <!-- Panels container -->
-  <div id="panels-container" class="layout-1" style="position:relative; flex:1; overflow:hidden;">
-
-    <!-- Welcome state (shown until first run) -->
-    <div id="welcome-overlay">
-      <h2>Traffic Visualizer</h2>
-      <p>
-        Upload a <strong>roadnet.json</strong> and select a scenario,
-        then click <strong>Run Simulations</strong> to compare policies
-        side by side.
-      </p>
-    </div>
-
-  </div>
-
-
-</div>
-
-<script src="/static/script_multi.js?v=20260308h"></script>
-</body>
-</html>
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>Traffic Visualizer</title>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/pixi.js/4.8.2/pixi.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/pixi-viewport@4.2.3/dist/viewport.min.js"></script>
+  <link rel="stylesheet" href="/static/style_multi.css?v=20260308h">
+  <script src="/static/Point.js?v=20260308h"></script>
+  <style>
+    @keyframes fadeInUp {
+      from { opacity: 0; transform: translateY(8px); }
+      to   { opacity: 1; transform: translateY(0); }
+    }
+  </style>
+</head>
+<body>
+
+<!-- ── Left sidebar ──��───────────────────────────────────── -->
+<aside id="sidebar">
+  <div>
+    <h1>Traffic Visualizer</h1>
+    <p class="subtitle">Multi-policy comparison dashboard</p>
+  </div>
+
+  <!-- 1. Roadnet upload -->
+  <div class="sidebar-section">
+    <h3>1. Upload Roadnet</h3>
+    <div id="roadnet-drop-zone">
+      <span class="drop-icon">&#x1F5FA;</span>
+      <div>Drop <strong>roadnet.json</strong> here</div>
+      <div style="font-size:11px; margin-top:4px; color:#555">or click to browse</div>
+      <div class="drop-filename"></div>
+    </div>
+    <input type="file" id="roadnet-file-input" accept=".json" />
+  </div>
+
+  <!-- 2. City / Scenario -->
+  <div class="sidebar-section">
+    <h3>2. Select Scenario</h3>
+    <div class="picker-row">
+      <label for="city-select">City</label>
+      <select id="city-select">
+        <option value="">-- loading --</option>
+      </select>
+    </div>
+    <div class="picker-row" style="margin-top:8px;">
+      <label for="scenario-select">Scenario</label>
+      <select id="scenario-select" disabled>
+        <option value="">-- select city first --</option>
+      </select>
+    </div>
+  </div>
+
+  <!-- 3. Policies -->
+  <div class="sidebar-section">
+    <h3>3. Policies</h3>
+    <div id="policy-list" class="policy-list"></div>
+  </div>
+
+  <!-- 4. View mode -->
+  <div class="sidebar-section">
+    <h3>4. View Mode</h3>
+    <div class="view-mode-row">
+      <button class="view-mode-btn active" data-panels="1">1</button>
+      <button class="view-mode-btn" data-panels="2">2</button>
+      <button class="view-mode-btn" data-panels="3">3</button>
+      <button class="view-mode-btn" data-panels="6">All 6</button>
+    </div>
+  </div>
+
+  <!-- Run -->
+  <button id="run-btn">Run Simulations</button>
+  <label class="force-rerun-row">
+    <input type="checkbox" id="force-rerun-checkbox" />
+    <span>Force rerun (ignore cache)</span>
+  </label>
+
+  <!-- Progress -->
+  <div class="sidebar-section" id="progress-section" style="display:none;"></div>
+
+  <!-- Debug log -->
+  <div class="sidebar-section" id="debug-log-section">
+    <h3>Debug Log</h3>
+    <div id="debug-log" class="debug-log"></div>
+  </div>
+
+  <!-- Recent runs -->
+  <div class="sidebar-section" id="recent-runs-section">
+    <h3>Recent Runs</h3>
+    <div id="recent-runs-list" class="recent-runs-list">
+      <div class="recent-run-empty">No saved runs yet.</div>
+    </div>
+  </div>
+</aside>
+
+<div id="sidebar-resize-handle"></div>
+
+<!-- ── Main area ─────────────────────────────────────────── -->
+<div id="main">
+
+  <!-- Playback toolbar -->
+  <div id="playback-bar">
+    <button id="pause-btn">Pause</button>
+    <button id="speed-down">&#8722;</button>
+    <input type="range" id="scrubber" min="0" max="0" value="0" />
+    <button id="speed-up">&#43;</button>
+    <span id="speed-label">0.5x</span>
+    <span id="step-display">0 / 0</span>
+  </div>
+
+  <div id="summary-bar">
+    <div class="summary-empty">Run a simulation to compare policy metrics.</div>
+  </div>
+
+  <!-- Panels container -->
+  <div id="panels-container" class="layout-1" style="position:relative; flex:1; overflow:hidden;">
+
+    <!-- Welcome state (shown until first run) -->
+    <div id="welcome-overlay">
+      <h2>Traffic Visualizer</h2>
+      <p>
+        Upload a <strong>roadnet.json</strong> and select a scenario,
+        then click <strong>Run Simulations</strong> to compare policies
+        side by side.
+      </p>
+    </div>
+
+  </div>
+
+
+</div>
+
+<script src="/static/script_multi.js?v=20260308h"></script>
+</body>
+</html>

third_party/CityFlow/frontend/script.js

@@ -1,1035 +1,1035 @@
-/**
- * Draw Road Network
- */
-id = Math.random().toString(36).substring(2, 15);
-
-BACKGROUND_COLOR = 0xe8ebed;
-LANE_COLOR = 0x586970;
-LANE_BORDER_WIDTH = 1;
-LANE_BORDER_COLOR = 0x82a8ba;
-LANE_INNER_COLOR = 0xbed8e8;
-LANE_DASH = 10;
-LANE_GAP = 12;
-TRAFFIC_LIGHT_WIDTH = 3;
-MAX_TRAFFIC_LIGHT_NUM = 100000;
-ROTATE = 90;
-
-CAR_LENGTH = 5;
-CAR_WIDTH = 2;
-CAR_COLOR = 0xe8bed4;
-
-CAR_COLORS = [0xf2bfd7, // pink
-            0xb7ebe4,   // cyan
-            0xdbebb7,   // blue
-            0xf5ddb5, 
-            0xd4b5f5];
-CAR_COLORS_NUM = CAR_COLORS.length;
-
-NUM_CAR_POOL = 150000;
-DISTRICT_BORDER_COLOR = 0x34495e;
-GATEWAY_NODE_COLOR = 0xf39c12;
-GATEWAY_EDGE_COLOR = 0xe67e22;
-DISTRICT_PALETTE = [
-    0x1f77b4, 0xff7f0e, 0x2ca02c, 0xd62728, 0x9467bd, 0x8c564b,
-    0xe377c2, 0x7f7f7f, 0xbcbd22, 0x17becf, 0x393b79, 0x637939
-];
-
-LIGHT_RED = 0xdb635e;
-LIGHT_GREEN = 0x85ee00;
-
-TURN_SIGNAL_COLOR = 0xFFFFFF;
-TURN_SIGNAL_WIDTH   = 1;
-TURN_SIGNAL_LENGTH  = 5;
-
-var simulation, roadnet, steps;
-var nodes = {};
-var edges = {};
-var logs;
-var gettingLog = false;
-
-let Application = PIXI.Application,
-    Sprite = PIXI.Sprite,
-    Graphics = PIXI.Graphics,
-    Container = PIXI.Container,
-    ParticleContainer = PIXI.particles.ParticleContainer,
-    Texture = PIXI.Texture,
-    Rectangle = PIXI.Rectangle
-;
-
-var controls = new function () {
-    this.replaySpeedMax = 1;
-    this.replaySpeedMin = 0.01;
-    this.replaySpeed = 0.5;
-    this.paused = false;
-};
-
-var trafficLightsG = {};
-
-var app, viewport, renderer, simulatorContainer, carContainer, trafficLightContainer;
-var overlayContainer;
-var turnSignalContainer;
-var carPool;
-
-var cnt = 0;
-var frameElapsed = 0;
-var totalStep;
-
-var nodeCarNum = document.getElementById("car-num");
-var nodeProgressPercentage = document.getElementById("progress-percentage");
-var nodeTotalStep = document.getElementById("total-step-num");
-var nodeCurrentStep = document.getElementById("current-step-num");
-var nodeSelectedEntity = document.getElementById("selected-entity");
-
-var SPEED = 3, SCALE_SPEED = 1.01;
-var LEFT = 37, UP = 38, RIGHT = 39, DOWN = 40;
-var MINUS = 189, EQUAL = 187, P = 80;
-var LEFT_BRACKET = 219, RIGHT_BRACKET = 221; 
-var ONE = 49, TWO = 50;
-var SPACE = 32;
-
-var keyDown = new Set();
-
-var turnSignalTextures = [];
-
-let pauseButton = document.getElementById("pause");
-let nodeCanvas = document.getElementById("simulator-canvas");
-let replayControlDom = document.getElementById("replay-control");
-let replaySpeedDom = document.getElementById("replay-speed");
-
-let loading = false;
-let infoDOM = document.getElementById("info");
-let selectedDOM = document.getElementById("selected-entity");
-
-function infoAppend(msg) {
-    infoDOM.innerText += "- " + msg + "\n";
-}
-
-function infoReset() {
-    infoDOM.innerText = "";
-}
-
-/**
- * Upload files
- */
-let ready = false;
-
-let roadnetData = [];
-let replayData = [];
-let chartData = [];
-let districtDataRaw = [];
-let districtMap = null;
-let showDistrictOverlay = true;
-let showGatewayOverlay = true;
-
-function handleChooseFile(v, label_dom) {
-    return function(evt) {
-        let file = evt.target.files[0];
-        label_dom.innerText = file.name;
-    }
-}
-
-function uploadFile(v, file, callback) {
-    let reader = new FileReader();
-    reader.onloadstart = function () {
-        infoAppend("Loading " + file.name);
-    };
-    reader.onerror = function() {
-        infoAppend("Loading " + file.name + "failed");
-    }
-    reader.onload = function (e) {
-        infoAppend(file.name + " loaded");
-        v[0] = e.target.result;
-        callback();
-    };
-    try {
-        reader.readAsText(file);
-    } catch (e) {
-        infoAppend("Loading failed");
-        console.error(e.message);
-    }
-}
-
-let debugMode = false;
-let chartLog;
-let showChart = false;
-let chartConainterDOM = document.getElementById("chart-container");
-let showDistrictOverlayDom = document.getElementById("show-district-overlay");
-let showGatewayOverlayDom = document.getElementById("show-gateway-overlay");
-
-function parseDistrictMap() {
-    if (!districtDataRaw[0]) {
-        districtMap = null;
-        return;
-    }
-    try {
-        districtMap = JSON.parse(districtDataRaw[0]);
-    } catch (e) {
-        districtMap = null;
-        infoAppend("Parsing district map file failed");
-    }
-}
-
-function uploadOptionalDistrictThenChart(done) {
-    if (DistrictFileDom.value) {
-        uploadFile(districtDataRaw, DistrictFileDom.files[0], function() {
-            parseDistrictMap();
-            if (ChartFileDom.value) {
-                showChart = true;
-                uploadFile(chartData, ChartFileDom.files[0], done);
-            } else {
-                showChart = false;
-                done();
-            }
-        });
-    } else {
-        districtMap = null;
-        if (ChartFileDom.value) {
-            showChart = true;
-            uploadFile(chartData, ChartFileDom.files[0], done);
-        } else {
-            showChart = false;
-            done();
-        }
-    }
-}
-
-function start() {
-    if (loading) return;
-    loading = true;
-    infoReset();
-    showDistrictOverlay = showDistrictOverlayDom.checked;
-    showGatewayOverlay = showGatewayOverlayDom.checked;
-    uploadFile(roadnetData, RoadnetFileDom.files[0], function(){
-    uploadFile(replayData, ReplayFileDom.files[0], function(){
-        let after_update = function() {
-            infoAppend("drawing roadnet");
-            ready = false;
-            document.getElementById("guide").classList.add("d-none");
-            hideCanvas();
-            try {
-                simulation = JSON.parse(roadnetData[0]);
-            } catch (e) {
-                infoAppend("Parsing roadnet file failed");
-                loading = false;
-                return;
-            }
-            try {
-                logs = replayData[0].split('\n');
-                logs.pop();
-            } catch (e) {
-                infoAppend("Reading replay file failed");
-                loading = false;
-                return;
-            }
-
-            totalStep = logs.length;
-            if (showChart) {
-                chartConainterDOM.classList.remove("d-none");
-                let chart_lines = chartData[0].split('\n');
-                if (chart_lines.length == 0) {
-                    infoAppend("Chart file is empty");
-                    showChart = false;
-                }
-                chartLog = [];
-                for (let i = 0 ; i < totalStep ; ++i) {
-                    step_data = chart_lines[i + 1].split(/[ \t]+/);
-                    chartLog.push([]);
-                    for (let j = 0; j < step_data.length; ++j) {
-                        chartLog[i].push(parseFloat(step_data[j]));
-                    }
-                }
-                chart.init(chart_lines[0], chartLog[0].length, totalStep);
-            }else {
-                chartConainterDOM.classList.add("d-none");
-            }
-
-            controls.paused = false;
-            cnt = 0;
-            debugMode = document.getElementById("debug-mode").checked;
-            setTimeout(function () {
-                try {
-                    drawRoadnet();
-                } catch (e) {
-                    infoAppend("Drawing roadnet failed");
-                    console.error(e.message);
-                    loading = false;
-                    return;
-                }
-                ready = true;
-                loading = false;
-                infoAppend("Start replaying");
-            }, 200);
-        };
-
-        uploadOptionalDistrictThenChart(after_update);
-
-    }); // replay callback
-    }); // roadnet callback
-}
-
-let RoadnetFileDom = document.getElementById("roadnet-file");
-let ReplayFileDom = document.getElementById("replay-file");
-let ChartFileDom = document.getElementById("chart-file");
-let DistrictFileDom = document.getElementById("district-file");
-
-RoadnetFileDom.addEventListener("change",
-    handleChooseFile(roadnetData, document.getElementById("roadnet-label")), false);
-ReplayFileDom.addEventListener("change",
-    handleChooseFile(replayData, document.getElementById("replay-label")), false);
-ChartFileDom.addEventListener("change",
-    handleChooseFile(chartData, document.getElementById("chart-label")), false);
-DistrictFileDom.addEventListener("change",
-    handleChooseFile(districtDataRaw, document.getElementById("district-label")), false);
-
-showDistrictOverlayDom.addEventListener("change", function(evt) {
-    showDistrictOverlay = evt.target.checked;
-    if (ready) drawRoadnet();
-});
-showGatewayOverlayDom.addEventListener("change", function(evt) {
-    showGatewayOverlay = evt.target.checked;
-    if (ready) drawRoadnet();
-});
-
-document.getElementById("start-btn").addEventListener("click", start);
-
-document.getElementById("slow-btn").addEventListener("click", function() {
-    updateReplaySpeed(controls.replaySpeed - 0.1);
-})
-
-document.getElementById("fast-btn").addEventListener("click", function() {
-    updateReplaySpeed(controls.replaySpeed + 0.1);
-})
-
-function updateReplaySpeed(speed){
-    speed = Math.min(speed, 1);
-    speed = Math.max(speed, 0);
-    controls.replaySpeed = speed;
-    replayControlDom.value = speed * 100;
-    replaySpeedDom.innerHTML = speed.toFixed(2);
-}
-
-updateReplaySpeed(0.5);
-
-replayControlDom.addEventListener('change', function(e){
-    updateReplaySpeed(replayControlDom.value / 100);
-});
-
-document.addEventListener('keydown', function(e) {
-    if (e.keyCode == P) {
-        controls.paused = !controls.paused;
-    } else if (e.keyCode == ONE) {
-        updateReplaySpeed(Math.max(controls.replaySpeed / 1.5, controls.replaySpeedMin));
-    } else if (e.keyCode == TWO ) {
-        updateReplaySpeed(Math.min(controls.replaySpeed * 1.5, controls.replaySpeedMax));
-    } else if (e.keyCode == LEFT_BRACKET) {
-        cnt = (cnt - 1) % totalStep;
-        cnt = (cnt + totalStep) % totalStep;
-        drawStep(cnt);
-    } else if (e.keyCode == RIGHT_BRACKET) {
-        cnt = (cnt + 1) % totalStep;
-        drawStep(cnt);
-    } else {
-        keyDown.add(e.keyCode)
-    }
-});
-
-document.addEventListener('keyup', (e) => keyDown.delete(e.keyCode));
-
-nodeCanvas.addEventListener('dblclick', function(e){
-    controls.paused = !controls.paused;
-});
-
-pauseButton.addEventListener('click', function(e){
-    controls.paused = !controls.paused;
-});
-
-function initCanvas() {
-    app = new Application({
-        width: nodeCanvas.offsetWidth,
-        height: nodeCanvas.offsetHeight,
-        transparent: false,
-        backgroundColor: BACKGROUND_COLOR
-    });
-
-    nodeCanvas.appendChild(app.view);
-    app.view.classList.add("d-none");
-
-    renderer = app.renderer;
-    renderer.interactive = true;
-    renderer.autoResize = true;
-
-    renderer.resize(nodeCanvas.offsetWidth, nodeCanvas.offsetHeight);
-    app.ticker.add(run);
-}
-
-function showCanvas() {
-    document.getElementById("spinner").classList.add("d-none");
-    app.view.classList.remove("d-none");
-}
-
-function hideCanvas() {
-    document.getElementById("spinner").classList.remove("d-none");
-    app.view.classList.add("d-none");
-}
-
-function drawRoadnet() {
-    if (simulatorContainer) {
-        simulatorContainer.destroy(true);
-    }
-    app.stage.removeChildren();
-    viewport = new Viewport.Viewport({
-        screenWidth: window.innerWidth,
-        screenHeight: window.innerHeight,
-        interaction: app.renderer.plugins.interaction
-    });
-    viewport
-        .drag()
-        .pinch()
-        .wheel()
-        .decelerate();
-    app.stage.addChild(viewport);
-    simulatorContainer = new Container();
-    viewport.addChild(simulatorContainer);
-
-    roadnet = simulation.static;
-    nodes = [];
-    edges = [];
-    trafficLightsG = {};
-
-    for (let i = 0, len = roadnet.nodes.length;i < len;++i) {
-        node = roadnet.nodes[i];
-        node.point = new Point(transCoord(node.point));
-        nodes[node.id] = node;
-    }
-
-    for (let i = 0, len = roadnet.edges.length;i < len;++i) {
-        edge = roadnet.edges[i];
-        edge.from = nodes[edge.from];
-        edge.to = nodes[edge.to];
-        for (let j = 0, len = edge.points.length;j < len;++j) {
-            edge.points[j] = new Point(transCoord(edge.points[j]));
-        }
-        edges[edge.id] = edge;
-    }
-
-    /**
-     * Draw Map
-     */
-    trafficLightContainer = new ParticleContainer(MAX_TRAFFIC_LIGHT_NUM, {tint: true});
-    let mapContainer, mapGraphics;
-    if (debugMode) {
-        mapContainer = new Container();
-        simulatorContainer.addChild(mapContainer);
-    }else {
-        mapGraphics = new Graphics();
-        simulatorContainer.addChild(mapGraphics);
-    }
-
-    for (nodeId in nodes) {
-        if (!nodes[nodeId].virtual) {
-            let nodeGraphics;
-            if (debugMode) {
-                nodeGraphics = new Graphics();
-                mapContainer.addChild(nodeGraphics);
-            } else {
-                nodeGraphics = mapGraphics;
-            }
-            drawNode(nodes[nodeId], nodeGraphics);
-        }
-    }
-    for (edgeId in edges) {
-        let edgeGraphics;
-        if (debugMode) {
-            edgeGraphics = new Graphics();
-            mapContainer.addChild(edgeGraphics);
-        } else {
-            edgeGraphics = mapGraphics;
-        }
-        drawEdge(edges[edgeId], edgeGraphics);
-    }
-    drawOverlayLayers();
-    let bounds = simulatorContainer.getBounds();
-    simulatorContainer.pivot.set(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2);
-    simulatorContainer.position.set(renderer.width / 2, renderer.height / 2);
-    simulatorContainer.addChild(trafficLightContainer);
-
-    /**
-     * Settings for Cars
-     */
-    TURN_SIGNAL_LENGTH = CAR_LENGTH;
-    TURN_SIGNAL_WIDTH  = CAR_WIDTH / 2;
-
-    var carG = new Graphics();
-    carG.lineStyle(0);
-    carG.beginFill(0xFFFFFF, 0.8);
-    carG.drawRect(0, 0, CAR_LENGTH, CAR_WIDTH);
-
-    let carTexture = renderer.generateTexture(carG);
-
-    let signalG = new Graphics();
-    signalG.beginFill(TURN_SIGNAL_COLOR, 0.7).drawRect(0,0, TURN_SIGNAL_LENGTH, TURN_SIGNAL_WIDTH)
-           .drawRect(0, 3 * CAR_WIDTH - TURN_SIGNAL_WIDTH, TURN_SIGNAL_LENGTH, TURN_SIGNAL_WIDTH).endFill();
-    let turnSignalTexture = renderer.generateTexture(signalG);
-
-    let signalLeft = new Texture(turnSignalTexture, new Rectangle(0, 0, TURN_SIGNAL_LENGTH, CAR_WIDTH));
-    let signalStraight = new Texture(turnSignalTexture, new Rectangle(0, CAR_WIDTH, TURN_SIGNAL_LENGTH, CAR_WIDTH));
-    let signalRight = new Texture(turnSignalTexture, new Rectangle(0, CAR_WIDTH * 2, TURN_SIGNAL_LENGTH, CAR_WIDTH));
-    turnSignalTextures = [signalLeft, signalStraight, signalRight];
-
-
-    carPool = [];
-    if (debugMode)
-        carContainer = new Container();
-    else
-        carContainer = new ParticleContainer(NUM_CAR_POOL, {rotation: true, tint: true});
-
-
-    turnSignalContainer = new ParticleContainer(NUM_CAR_POOL, {rotation: true, tint: true});
-    simulatorContainer.addChild(carContainer);
-    simulatorContainer.addChild(turnSignalContainer);
-    for (let i = 0, len = NUM_CAR_POOL;i < len;++i) {
-        //var car = Sprite.fromImage("images/car.png")
-        let car = new Sprite(carTexture);
-        let signal = new Sprite(turnSignalTextures[1]);
-        car.anchor.set(1, 0.5);
-
-        if (debugMode) {
-            car.interactive = true;
-            car.on('mouseover', function () {
-                selectedDOM.innerText = car.name;
-                car.alpha = 0.8;
-            });
-            car.on('mouseout', function () {
-                // selectedDOM.innerText = "";
-                car.alpha = 1;
-            });
-        }
-        signal.anchor.set(1, 0.5);
-        carPool.push([car, signal]);
-    }
-    showCanvas();
-
-    return true;
-}
-
-function appendText(id, text) {
-    let p = document.createElement("span");
-    p.innerText = text;
-    document.getElementById("info").appendChild(p);
-    document.getElementById("info").appendChild(document.createElement("br"));
-}
-
-var statsFile = "";
-var withRange = false;
-var nodeStats, nodeRange;
-
-initCanvas();
-
-
-function transCoord(point) {
-    return [point[0], -point[1]];
-}
-
-function getDistrictColor(districtId) {
-    return DISTRICT_PALETTE[stringHash(districtId) % DISTRICT_PALETTE.length];
-}
-
-function cross2D(o, a, b) {
-    return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
-}
-
-function convexHull(points) {
-    if (!points || points.length <= 2) return points ? points.slice() : [];
-    let sorted = points
-        .slice()
-        .sort((p, q) => (p.x === q.x ? p.y - q.y : p.x - q.x));
-    let lower = [];
-    for (let i = 0; i < sorted.length; ++i) {
-        while (lower.length >= 2 && cross2D(lower[lower.length - 2], lower[lower.length - 1], sorted[i]) <= 0) {
-            lower.pop();
-        }
-        lower.push(sorted[i]);
-    }
-    let upper = [];
-    for (let i = sorted.length - 1; i >= 0; --i) {
-        while (upper.length >= 2 && cross2D(upper[upper.length - 2], upper[upper.length - 1], sorted[i]) <= 0) {
-            upper.pop();
-        }
-        upper.push(sorted[i]);
-    }
-    lower.pop();
-    upper.pop();
-    return lower.concat(upper);
-}
-
-function drawDistrictRegionFills(graphics, districtToPoints) {
-    for (let districtId in districtToPoints) {
-        let pts = districtToPoints[districtId];
-        if (!pts || pts.length === 0) continue;
-        let color = getDistrictColor(districtId);
-        if (pts.length >= 3) {
-            let hull = convexHull(pts);
-            if (hull.length >= 3) {
-                graphics.lineStyle(1.2, color, 0.35);
-                graphics.beginFill(color, 0.11);
-                graphics.moveTo(hull[0].x, hull[0].y);
-                for (let i = 1; i < hull.length; ++i) {
-                    graphics.lineTo(hull[i].x, hull[i].y);
-                }
-                graphics.lineTo(hull[0].x, hull[0].y);
-                graphics.endFill();
-                continue;
-            }
-        }
-        if (pts.length === 2) {
-            graphics.lineStyle(18, color, 0.10);
-            graphics.drawLine(pts[0], pts[1]);
-            continue;
-        }
-        graphics.lineStyle(0);
-        graphics.beginFill(color, 0.12);
-        graphics.drawCircle(pts[0].x, pts[0].y, 18);
-        graphics.endFill();
-    }
-}
-
-function drawEdgePolyline(graphics, edge, width, color, alpha) {
-    graphics.lineStyle(width, color, alpha);
-    for (let i = 1; i < edge.points.length; ++i) {
-        graphics.drawLine(edge.points[i - 1], edge.points[i]);
-    }
-}
-
-function drawOverlayLayers() {
-    if (overlayContainer) {
-        overlayContainer.destroy(true);
-        overlayContainer = null;
-    }
-    if (!showDistrictOverlay && !showGatewayOverlay) {
-        return;
-    }
-    overlayContainer = new Container();
-    simulatorContainer.addChild(overlayContainer);
-
-    let overlayGraphics = new Graphics();
-    overlayContainer.addChild(overlayGraphics);
-
-    let intersectionToDistrict = {};
-    if (districtMap && districtMap.intersection_to_district) {
-        intersectionToDistrict = districtMap.intersection_to_district;
-    }
-    let gatewayNodeIds = new Set(
-        districtMap && districtMap.gateway_intersections
-            ? districtMap.gateway_intersections
-            : []
-    );
-    let gatewayEdgeIds = new Set(
-        districtMap && districtMap.gateway_roads
-            ? districtMap.gateway_roads
-            : []
-    );
-    let nodeDegree = {};
-    for (let edgeId in edges) {
-        let edge = edges[edgeId];
-        nodeDegree[edge.from.id] = (nodeDegree[edge.from.id] || 0) + 1;
-        nodeDegree[edge.to.id] = (nodeDegree[edge.to.id] || 0) + 1;
-    }
-    for (let nodeId in nodes) {
-        if ((nodeDegree[nodeId] || 0) <= 1) {
-            gatewayNodeIds.add(nodeId);
-        }
-    }
-
-    if (showDistrictOverlay && districtMap && districtMap.intersection_to_district) {
-        let districtToPoints = {};
-        for (let nodeId in nodes) {
-            let districtId = intersectionToDistrict[nodeId];
-            if (!districtId) continue;
-            if (!districtToPoints[districtId]) districtToPoints[districtId] = [];
-            districtToPoints[districtId].push(nodes[nodeId].point);
-        }
-        drawDistrictRegionFills(overlayGraphics, districtToPoints);
-
-        for (let edgeId in edges) {
-            let edge = edges[edgeId];
-            let fromDistrict = intersectionToDistrict[edge.from.id];
-            let toDistrict = intersectionToDistrict[edge.to.id];
-            if (!fromDistrict || !toDistrict) continue;
-            if (fromDistrict === toDistrict) {
-                drawEdgePolyline(
-                    overlayGraphics,
-                    edge,
-                    1.2,
-                    getDistrictColor(fromDistrict),
-                    0.45
-                );
-            } else {
-                drawEdgePolyline(
-                    overlayGraphics,
-                    edge,
-                    1.8,
-                    DISTRICT_BORDER_COLOR,
-                    0.8
-                );
-            }
-        }
-        for (let nodeId in nodes) {
-            let districtId = intersectionToDistrict[nodeId];
-            if (!districtId) continue;
-            let point = nodes[nodeId].point;
-            overlayGraphics.beginFill(getDistrictColor(districtId), 0.55);
-            overlayGraphics.drawCircle(point.x, point.y, 2.0);
-            overlayGraphics.endFill();
-        }
-    }
-
-    if (showGatewayOverlay) {
-        for (let edgeId in edges) {
-            let edge = edges[edgeId];
-            let fromGateway = gatewayNodeIds.has(edge.from.id) || String(edge.from.id).indexOf("g_") === 0;
-            let toGateway = gatewayNodeIds.has(edge.to.id) || String(edge.to.id).indexOf("g_") === 0;
-            let edgeLooksGateway = edgeId.indexOf("_g_") >= 0 || edgeId.indexOf("r_g_") === 0;
-            if (
-                gatewayEdgeIds.has(edgeId)
-                || fromGateway
-                || toGateway
-                || edgeLooksGateway
-            ) {
-                drawEdgePolyline(
-                    overlayGraphics,
-                    edge,
-                    5.6,
-                    GATEWAY_EDGE_COLOR,
-                    0.82
-                );
-            }
-        }
-        for (let nodeId in nodes) {
-            if (gatewayNodeIds.has(nodeId) || String(nodeId).indexOf("g_") === 0) {
-                let point = nodes[nodeId].point;
-                overlayGraphics.lineStyle(0);
-                overlayGraphics.beginFill(GATEWAY_NODE_COLOR, 0.28);
-                overlayGraphics.drawCircle(point.x, point.y, 34.0);
-                overlayGraphics.endFill();
-                overlayGraphics.lineStyle(2.2, 0x1f2d3d, 0.98);
-                overlayGraphics.beginFill(GATEWAY_NODE_COLOR, 0.96);
-                overlayGraphics.drawCircle(point.x, point.y, 13.0);
-                overlayGraphics.endFill();
-                overlayGraphics.lineStyle(0);
-                overlayGraphics.beginFill(0xffffff, 0.92);
-                overlayGraphics.drawCircle(point.x, point.y, 5.2);
-                overlayGraphics.endFill();
-            }
-        }
-    }
-}
-
-PIXI.Graphics.prototype.drawLine = function(pointA, pointB) {
-    this.moveTo(pointA.x, pointA.y);
-    this.lineTo(pointB.x, pointB.y);
-}
-
-PIXI.Graphics.prototype.drawDashLine = function(pointA, pointB, dash = 16, gap = 8) {
-    let direct = pointA.directTo(pointB);
-    let distance = pointA.distanceTo(pointB);
-
-    let currentPoint = pointA;
-    let currentDistance = 0;
-    let length;
-    let finish = false;
-    while (true) {
-        this.moveTo(currentPoint.x, currentPoint.y);
-        if (currentDistance + dash >= distance) {
-            length = distance - currentDistance;
-            finish = true;
-        } else {
-            length = dash
-        }
-        currentPoint = currentPoint.moveAlong(direct, length);
-        this.lineTo(currentPoint.x, currentPoint.y);
-        if (finish) break;
-        currentDistance += length;
-
-        if (currentDistance + gap >= distance) {
-            break;
-        } else {
-            currentPoint = currentPoint.moveAlong(direct, gap);
-            currentDistance += gap;
-        }
-    }
-};
-
-function drawNode(node, graphics) {
-    graphics.beginFill(LANE_COLOR);
-    let outline = node.outline;
-    for (let i = 0 ; i < outline.length ; i+=2) {
-        outline[i+1] = -outline[i+1];
-        if (i == 0)
-            graphics.moveTo(outline[i], outline[i+1]);
-        else
-            graphics.lineTo(outline[i], outline[i+1]);
-    }
-    graphics.endFill();
-
-    if (debugMode) {
-        graphics.hitArea = new PIXI.Polygon(outline);
-        graphics.interactive = true;
-        graphics.on("mouseover", function () {
-            selectedDOM.innerText = node.id;
-            graphics.alpha = 0.5;
-        });
-        graphics.on("mouseout", function () {
-            graphics.alpha = 1;
-        });
-    }
-
-}
-
-function drawEdge(edge, graphics) {
-    let from = edge.from;
-    let to = edge.to;
-    let points = edge.points;
-
-    let pointA, pointAOffset, pointB, pointBOffset;
-    let prevPointBOffset = null;
-
-    let roadWidth = 0;
-    edge.laneWidths.forEach(function(l){
-        roadWidth += l;
-    }, 0);
-
-    let coords = [], coords1 = [];
-
-    for (let i = 1;i < points.length;++i) {
-        if (i == 1){
-            pointA = points[0].moveAlongDirectTo(points[1], from.virtual ? 0 : from.width);
-            pointAOffset = points[0].directTo(points[1]).rotate(ROTATE);
-        } else {
-            pointA = points[i-1];
-            pointAOffset = prevPointBOffset;
-        }
-        if (i == points.length - 1) {
-            pointB = points[i].moveAlongDirectTo(points[i-1], to.virtual ? 0 : to.width);
-            pointBOffset = points[i-1].directTo(points[i]).rotate(ROTATE);
-        } else {
-            pointB = points[i];
-            pointBOffset = points[i-1].directTo(points[i+1]).rotate(ROTATE);
-        }
-        prevPointBOffset = pointBOffset;
-
-        lightG = new Graphics();
-        lightG.lineStyle(TRAFFIC_LIGHT_WIDTH, 0xFFFFFF);
-        lightG.drawLine(new Point(0, 0), new Point(1, 0));
-        lightTexture = renderer.generateTexture(lightG);
-
-        // Draw Traffic Lights
-        if (i == points.length-1 && !to.virtual) {
-            edgeTrafficLights = [];
-            prevOffset = offset = 0;
-            for (lane = 0;lane < edge.nLane;++lane) {
-                offset += edge.laneWidths[lane];
-                var light = new Sprite(lightTexture);
-                light.anchor.set(0, 0.5);
-                light.scale.set(offset - prevOffset, 1);
-                point_ = pointB.moveAlong(pointBOffset, prevOffset);
-                light.position.set(point_.x, point_.y);
-                light.rotation = pointBOffset.getAngleInRadians();
-                edgeTrafficLights.push(light);
-                prevOffset = offset;
-                trafficLightContainer.addChild(light);
-            }
-            trafficLightsG[edge.id] = edgeTrafficLights;
-        }
-
-        // Draw Roads
-        graphics.lineStyle(LANE_BORDER_WIDTH, LANE_BORDER_COLOR, 1);
-        graphics.drawLine(pointA, pointB);
-
-        pointA1 = pointA.moveAlong(pointAOffset, roadWidth);
-        pointB1 = pointB.moveAlong(pointBOffset, roadWidth);
-
-        graphics.lineStyle(0);
-        graphics.beginFill(LANE_COLOR);
-
-        coords = coords.concat([pointA.x, pointA.y, pointB.x, pointB.y]);
-        coords1 = coords1.concat([pointA1.y, pointA1.x, pointB1.y, pointB1.x]);
-
-        graphics.drawPolygon([pointA.x, pointA.y, pointB.x, pointB.y, pointB1.x, pointB1.y, pointA1.x, pointA1.y]);
-        graphics.endFill();
-
-        offset = 0;
-        for (let lane = 0, len = edge.nLane-1;lane < len;++lane) {
-            offset += edge.laneWidths[lane];
-            graphics.lineStyle(LANE_BORDER_WIDTH, LANE_INNER_COLOR);
-            graphics.drawDashLine(pointA.moveAlong(pointAOffset, offset), pointB.moveAlong(pointBOffset, offset), LANE_DASH, LANE_GAP);
-        }
-
-        offset += edge.laneWidths[edge.nLane-1];
-
-        // graphics.lineStyle(LANE_BORDER_WIDTH, LANE_BORDER_COLOR);
-        // graphics.drawLine(pointA.moveAlong(pointAOffset, offset), pointB.moveAlong(pointBOffset, offset));
-    }
-
-    if (debugMode) {
-        coords = coords.concat(coords1.reverse());
-        graphics.interactive = true;
-        graphics.hitArea = new PIXI.Polygon(coords);
-        graphics.on("mouseover", function () {
-            graphics.alpha = 0.5;
-            selectedDOM.innerText = edge.id;
-        });
-
-        graphics.on("mouseout", function () {
-            graphics.alpha = 1;
-        });
-    }
-}
-
-function run(delta) {
-    let redraw = false;
-
-    if (ready && (!controls.paused || redraw)) {
-        try {
-            drawStep(cnt);
-        }catch (e) {
-            infoAppend("Error occurred when drawing");
-            ready = false;
-        }
-        if (!controls.paused) {
-            frameElapsed += 1;
-            if (frameElapsed >= 1 / controls.replaySpeed ** 2) {
-                cnt += 1;
-                frameElapsed = 0;
-                if (cnt == totalStep) cnt = 0;
-            }
-        }
-    }
-}
-
-function _statusToColor(status) {
-    switch (status) {
-        case 'r':
-            return LIGHT_RED;
-        case 'g':
-            return LIGHT_GREEN;
-        default:
-            return 0x808080;  
-    }
-}
-
-function stringHash(str) {
-    let hash = 0;
-    let p = 127, p_pow = 1;
-    let m = 1e9 + 9;
-    for (let i = 0; i < str.length; i++) {
-        hash = (hash + str.charCodeAt(i) * p_pow) % m;
-        p_pow = (p_pow * p) % m;
-    }
-    return hash;
-}
-
-function drawStep(step) {
-    if (showChart && (step > chart.ptr || step == 0)) {
-        if (step == 0) {
-            chart.clear();
-        }
-        chart.ptr = step;
-        chart.addData(chartLog[step]);
-    }
-
-    let [carLogs, tlLogs] = logs[step].split(';');
-
-    tlLogs = tlLogs.split(',');
-    carLogs = carLogs.split(',');
-    
-    let tlLog, tlEdge, tlStatus;
-    for (let i = 0, len = tlLogs.length;i < len;++i) {
-        tlLog = tlLogs[i].split(' ');
-        tlEdge = tlLog[0];
-        tlStatus = tlLog.slice(1);
-        for (let j = 0, len = tlStatus.length;j < len;++j) {
-            trafficLightsG[tlEdge][j].tint = _statusToColor(tlStatus[j]);
-            if (tlStatus[j] == 'i' ) {
-                trafficLightsG[tlEdge][j].alpha = 0;
-            }else{
-                trafficLightsG[tlEdge][j].alpha = 1;
-            }
-        }
-    }
-
-    carContainer.removeChildren();
-    turnSignalContainer.removeChildren();
-    let carLog, position, length, width;
-    for (let i = 0, len = carLogs.length - 1;i < len;++i) {
-        carLog = carLogs[i].split(' ');
-        position = transCoord([parseFloat(carLog[0]), parseFloat(carLog[1])]);
-        length = parseFloat(carLog[5]);
-        width = parseFloat(carLog[6]);
-        carPool[i][0].position.set(position[0], position[1]);
-        carPool[i][0].rotation = 2*Math.PI - parseFloat(carLog[2]);
-        carPool[i][0].name = carLog[3];
-        let carColorId = stringHash(carLog[3]) % CAR_COLORS_NUM;
-        carPool[i][0].tint = CAR_COLORS[carColorId];
-        carPool[i][0].width = length;
-        carPool[i][0].height = width;
-        carContainer.addChild(carPool[i][0]);
-
-        let laneChange = parseInt(carLog[4]) + 1;
-        carPool[i][1].position.set(position[0], position[1]);
-        carPool[i][1].rotation = carPool[i][0].rotation;
-        carPool[i][1].texture = turnSignalTextures[laneChange];
-        carPool[i][1].width = length;
-        carPool[i][1].height = width;
-        turnSignalContainer.addChild(carPool[i][1]);
-    }
-    nodeCarNum.innerText = carLogs.length-1;
-    nodeTotalStep.innerText = totalStep;
-    nodeCurrentStep.innerText = cnt+1;
-    nodeProgressPercentage.innerText = (cnt / totalStep * 100).toFixed(2) + "%";
-    if (statsFile != "") {
-        if (withRange) nodeRange.value = stats[step][1];
-        nodeStats.innerText = stats[step][0].toFixed(2);
-    }
-}
-
-/*
-Chart
- */
-let chart = {
-    max_steps: 3600,
-    data: {
-        labels: [],
-        series: [[]]
-    },
-    options: {
-        showPoint: false,
-        lineSmooth: false,
-        axisX: {
-            showGrid: false,
-            showLabel: false
-        }
-    },
-    init : function(title, series_cnt, max_step){
-        document.getElementById("chart-title").innerText = title;
-        this.max_steps = max_step;
-        this.data.labels = new Array(this.max_steps);
-        this.data.series = [];
-        for (let i = 0 ; i < series_cnt ; ++i)
-            this.data.series.push([]);
-        this.chart = new Chartist.Line('#chart', this.data, this.options);
-    },
-    addData: function (value) {
-        for (let i = 0 ; i < value.length; ++i) {
-            this.data.series[i].push(value[i]);
-            if (this.data.series[i].length > this.max_steps) {
-                this.data.series[i].shift();
-            }
-        }
-        this.chart.update();
-    },
-    clear: function() {
-        for (let i = 0 ; i < this.data.series.length ; ++i)
-            this.data.series[i] = [];
-    },
-    ptr: 0
-};
+/**
+ * Draw Road Network
+ */
+id = Math.random().toString(36).substring(2, 15);
+
+BACKGROUND_COLOR = 0xe8ebed;
+LANE_COLOR = 0x586970;
+LANE_BORDER_WIDTH = 1;
+LANE_BORDER_COLOR = 0x82a8ba;
+LANE_INNER_COLOR = 0xbed8e8;
+LANE_DASH = 10;
+LANE_GAP = 12;
+TRAFFIC_LIGHT_WIDTH = 3;
+MAX_TRAFFIC_LIGHT_NUM = 100000;
+ROTATE = 90;
+
+CAR_LENGTH = 5;
+CAR_WIDTH = 2;
+CAR_COLOR = 0xe8bed4;
+
+CAR_COLORS = [0xf2bfd7, // pink
+            0xb7ebe4,   // cyan
+            0xdbebb7,   // blue
+            0xf5ddb5, 
+            0xd4b5f5];
+CAR_COLORS_NUM = CAR_COLORS.length;
+
+NUM_CAR_POOL = 150000;
+DISTRICT_BORDER_COLOR = 0x34495e;
+GATEWAY_NODE_COLOR = 0xf39c12;
+GATEWAY_EDGE_COLOR = 0xe67e22;
+DISTRICT_PALETTE = [
+    0x1f77b4, 0xff7f0e, 0x2ca02c, 0xd62728, 0x9467bd, 0x8c564b,
+    0xe377c2, 0x7f7f7f, 0xbcbd22, 0x17becf, 0x393b79, 0x637939
+];
+
+LIGHT_RED = 0xdb635e;
+LIGHT_GREEN = 0x85ee00;
+
+TURN_SIGNAL_COLOR = 0xFFFFFF;
+TURN_SIGNAL_WIDTH   = 1;
+TURN_SIGNAL_LENGTH  = 5;
+
+var simulation, roadnet, steps;
+var nodes = {};
+var edges = {};
+var logs;
+var gettingLog = false;
+
+let Application = PIXI.Application,
+    Sprite = PIXI.Sprite,
+    Graphics = PIXI.Graphics,
+    Container = PIXI.Container,
+    ParticleContainer = PIXI.particles.ParticleContainer,
+    Texture = PIXI.Texture,
+    Rectangle = PIXI.Rectangle
+;
+
+var controls = new function () {
+    this.replaySpeedMax = 1;
+    this.replaySpeedMin = 0.01;
+    this.replaySpeed = 0.5;
+    this.paused = false;
+};
+
+var trafficLightsG = {};
+
+var app, viewport, renderer, simulatorContainer, carContainer, trafficLightContainer;
+var overlayContainer;
+var turnSignalContainer;
+var carPool;
+
+var cnt = 0;
+var frameElapsed = 0;
+var totalStep;
+
+var nodeCarNum = document.getElementById("car-num");
+var nodeProgressPercentage = document.getElementById("progress-percentage");
+var nodeTotalStep = document.getElementById("total-step-num");
+var nodeCurrentStep = document.getElementById("current-step-num");
+var nodeSelectedEntity = document.getElementById("selected-entity");
+
+var SPEED = 3, SCALE_SPEED = 1.01;
+var LEFT = 37, UP = 38, RIGHT = 39, DOWN = 40;
+var MINUS = 189, EQUAL = 187, P = 80;
+var LEFT_BRACKET = 219, RIGHT_BRACKET = 221; 
+var ONE = 49, TWO = 50;
+var SPACE = 32;
+
+var keyDown = new Set();
+
+var turnSignalTextures = [];
+
+let pauseButton = document.getElementById("pause");
+let nodeCanvas = document.getElementById("simulator-canvas");
+let replayControlDom = document.getElementById("replay-control");
+let replaySpeedDom = document.getElementById("replay-speed");
+
+let loading = false;
+let infoDOM = document.getElementById("info");
+let selectedDOM = document.getElementById("selected-entity");
+
+function infoAppend(msg) {
+    infoDOM.innerText += "- " + msg + "\n";
+}
+
+function infoReset() {
+    infoDOM.innerText = "";
+}
+
+/**
+ * Upload files
+ */
+let ready = false;
+
+let roadnetData = [];
+let replayData = [];
+let chartData = [];
+let districtDataRaw = [];
+let districtMap = null;
+let showDistrictOverlay = true;
+let showGatewayOverlay = true;
+
+function handleChooseFile(v, label_dom) {
+    return function(evt) {
+        let file = evt.target.files[0];
+        label_dom.innerText = file.name;
+    }
+}
+
+function uploadFile(v, file, callback) {
+    let reader = new FileReader();
+    reader.onloadstart = function () {
+        infoAppend("Loading " + file.name);
+    };
+    reader.onerror = function() {
+        infoAppend("Loading " + file.name + "failed");
+    }
+    reader.onload = function (e) {
+        infoAppend(file.name + " loaded");
+        v[0] = e.target.result;
+        callback();
+    };
+    try {
+        reader.readAsText(file);
+    } catch (e) {
+        infoAppend("Loading failed");
+        console.error(e.message);
+    }
+}
+
+let debugMode = false;
+let chartLog;
+let showChart = false;
+let chartConainterDOM = document.getElementById("chart-container");
+let showDistrictOverlayDom = document.getElementById("show-district-overlay");
+let showGatewayOverlayDom = document.getElementById("show-gateway-overlay");
+
+function parseDistrictMap() {
+    if (!districtDataRaw[0]) {
+        districtMap = null;
+        return;
+    }
+    try {
+        districtMap = JSON.parse(districtDataRaw[0]);
+    } catch (e) {
+        districtMap = null;
+        infoAppend("Parsing district map file failed");
+    }
+}
+
+function uploadOptionalDistrictThenChart(done) {
+    if (DistrictFileDom.value) {
+        uploadFile(districtDataRaw, DistrictFileDom.files[0], function() {
+            parseDistrictMap();
+            if (ChartFileDom.value) {
+                showChart = true;
+                uploadFile(chartData, ChartFileDom.files[0], done);
+            } else {
+                showChart = false;
+                done();
+            }
+        });
+    } else {
+        districtMap = null;
+        if (ChartFileDom.value) {
+            showChart = true;
+            uploadFile(chartData, ChartFileDom.files[0], done);
+        } else {
+            showChart = false;
+            done();
+        }
+    }
+}
+
+function start() {
+    if (loading) return;
+    loading = true;
+    infoReset();
+    showDistrictOverlay = showDistrictOverlayDom.checked;
+    showGatewayOverlay = showGatewayOverlayDom.checked;
+    uploadFile(roadnetData, RoadnetFileDom.files[0], function(){
+    uploadFile(replayData, ReplayFileDom.files[0], function(){
+        let after_update = function() {
+            infoAppend("drawing roadnet");
+            ready = false;
+            document.getElementById("guide").classList.add("d-none");
+            hideCanvas();
+            try {
+                simulation = JSON.parse(roadnetData[0]);
+            } catch (e) {
+                infoAppend("Parsing roadnet file failed");
+                loading = false;
+                return;
+            }
+            try {
+                logs = replayData[0].split('\n');
+                logs.pop();
+            } catch (e) {
+                infoAppend("Reading replay file failed");
+                loading = false;
+                return;
+            }
+
+            totalStep = logs.length;
+            if (showChart) {
+                chartConainterDOM.classList.remove("d-none");
+                let chart_lines = chartData[0].split('\n');
+                if (chart_lines.length == 0) {
+                    infoAppend("Chart file is empty");
+                    showChart = false;
+                }
+                chartLog = [];
+                for (let i = 0 ; i < totalStep ; ++i) {
+                    step_data = chart_lines[i + 1].split(/[ \t]+/);
+                    chartLog.push([]);
+                    for (let j = 0; j < step_data.length; ++j) {
+                        chartLog[i].push(parseFloat(step_data[j]));
+                    }
+                }
+                chart.init(chart_lines[0], chartLog[0].length, totalStep);
+            }else {
+                chartConainterDOM.classList.add("d-none");
+            }
+
+            controls.paused = false;
+            cnt = 0;
+            debugMode = document.getElementById("debug-mode").checked;
+            setTimeout(function () {
+                try {
+                    drawRoadnet();
+                } catch (e) {
+                    infoAppend("Drawing roadnet failed");
+                    console.error(e.message);
+                    loading = false;
+                    return;
+                }
+                ready = true;
+                loading = false;
+                infoAppend("Start replaying");
+            }, 200);
+        };
+
+        uploadOptionalDistrictThenChart(after_update);
+
+    }); // replay callback
+    }); // roadnet callback
+}
+
+let RoadnetFileDom = document.getElementById("roadnet-file");
+let ReplayFileDom = document.getElementById("replay-file");
+let ChartFileDom = document.getElementById("chart-file");
+let DistrictFileDom = document.getElementById("district-file");
+
+RoadnetFileDom.addEventListener("change",
+    handleChooseFile(roadnetData, document.getElementById("roadnet-label")), false);
+ReplayFileDom.addEventListener("change",
+    handleChooseFile(replayData, document.getElementById("replay-label")), false);
+ChartFileDom.addEventListener("change",
+    handleChooseFile(chartData, document.getElementById("chart-label")), false);
+DistrictFileDom.addEventListener("change",
+    handleChooseFile(districtDataRaw, document.getElementById("district-label")), false);
+
+showDistrictOverlayDom.addEventListener("change", function(evt) {
+    showDistrictOverlay = evt.target.checked;
+    if (ready) drawRoadnet();
+});
+showGatewayOverlayDom.addEventListener("change", function(evt) {
+    showGatewayOverlay = evt.target.checked;
+    if (ready) drawRoadnet();
+});
+
+document.getElementById("start-btn").addEventListener("click", start);
+
+document.getElementById("slow-btn").addEventListener("click", function() {
+    updateReplaySpeed(controls.replaySpeed - 0.1);
+})
+
+document.getElementById("fast-btn").addEventListener("click", function() {
+    updateReplaySpeed(controls.replaySpeed + 0.1);
+})
+
+function updateReplaySpeed(speed){
+    speed = Math.min(speed, 1);
+    speed = Math.max(speed, 0);
+    controls.replaySpeed = speed;
+    replayControlDom.value = speed * 100;
+    replaySpeedDom.innerHTML = speed.toFixed(2);
+}
+
+updateReplaySpeed(0.5);
+
+replayControlDom.addEventListener('change', function(e){
+    updateReplaySpeed(replayControlDom.value / 100);
+});
+
+document.addEventListener('keydown', function(e) {
+    if (e.keyCode == P) {
+        controls.paused = !controls.paused;
+    } else if (e.keyCode == ONE) {
+        updateReplaySpeed(Math.max(controls.replaySpeed / 1.5, controls.replaySpeedMin));
+    } else if (e.keyCode == TWO ) {
+        updateReplaySpeed(Math.min(controls.replaySpeed * 1.5, controls.replaySpeedMax));
+    } else if (e.keyCode == LEFT_BRACKET) {
+        cnt = (cnt - 1) % totalStep;
+        cnt = (cnt + totalStep) % totalStep;
+        drawStep(cnt);
+    } else if (e.keyCode == RIGHT_BRACKET) {
+        cnt = (cnt + 1) % totalStep;
+        drawStep(cnt);
+    } else {
+        keyDown.add(e.keyCode)
+    }
+});
+
+document.addEventListener('keyup', (e) => keyDown.delete(e.keyCode));
+
+nodeCanvas.addEventListener('dblclick', function(e){
+    controls.paused = !controls.paused;
+});
+
+pauseButton.addEventListener('click', function(e){
+    controls.paused = !controls.paused;
+});
+
+function initCanvas() {
+    app = new Application({
+        width: nodeCanvas.offsetWidth,
+        height: nodeCanvas.offsetHeight,
+        transparent: false,
+        backgroundColor: BACKGROUND_COLOR
+    });
+
+    nodeCanvas.appendChild(app.view);
+    app.view.classList.add("d-none");
+
+    renderer = app.renderer;
+    renderer.interactive = true;
+    renderer.autoResize = true;
+
+    renderer.resize(nodeCanvas.offsetWidth, nodeCanvas.offsetHeight);
+    app.ticker.add(run);
+}
+
+function showCanvas() {
+    document.getElementById("spinner").classList.add("d-none");
+    app.view.classList.remove("d-none");
+}
+
+function hideCanvas() {
+    document.getElementById("spinner").classList.remove("d-none");
+    app.view.classList.add("d-none");
+}
+
+function drawRoadnet() {
+    if (simulatorContainer) {
+        simulatorContainer.destroy(true);
+    }
+    app.stage.removeChildren();
+    viewport = new Viewport.Viewport({
+        screenWidth: window.innerWidth,
+        screenHeight: window.innerHeight,
+        interaction: app.renderer.plugins.interaction
+    });
+    viewport
+        .drag()
+        .pinch()
+        .wheel()
+        .decelerate();
+    app.stage.addChild(viewport);
+    simulatorContainer = new Container();
+    viewport.addChild(simulatorContainer);
+
+    roadnet = simulation.static;
+    nodes = [];
+    edges = [];
+    trafficLightsG = {};
+
+    for (let i = 0, len = roadnet.nodes.length;i < len;++i) {
+        node = roadnet.nodes[i];
+        node.point = new Point(transCoord(node.point));
+        nodes[node.id] = node;
+    }
+
+    for (let i = 0, len = roadnet.edges.length;i < len;++i) {
+        edge = roadnet.edges[i];
+        edge.from = nodes[edge.from];
+        edge.to = nodes[edge.to];
+        for (let j = 0, len = edge.points.length;j < len;++j) {
+            edge.points[j] = new Point(transCoord(edge.points[j]));
+        }
+        edges[edge.id] = edge;
+    }
+
+    /**
+     * Draw Map
+     */
+    trafficLightContainer = new ParticleContainer(MAX_TRAFFIC_LIGHT_NUM, {tint: true});
+    let mapContainer, mapGraphics;
+    if (debugMode) {
+        mapContainer = new Container();
+        simulatorContainer.addChild(mapContainer);
+    }else {
+        mapGraphics = new Graphics();
+        simulatorContainer.addChild(mapGraphics);
+    }
+
+    for (nodeId in nodes) {
+        if (!nodes[nodeId].virtual) {
+            let nodeGraphics;
+            if (debugMode) {
+                nodeGraphics = new Graphics();
+                mapContainer.addChild(nodeGraphics);
+            } else {
+                nodeGraphics = mapGraphics;
+            }
+            drawNode(nodes[nodeId], nodeGraphics);
+        }
+    }
+    for (edgeId in edges) {
+        let edgeGraphics;
+        if (debugMode) {
+            edgeGraphics = new Graphics();
+            mapContainer.addChild(edgeGraphics);
+        } else {
+            edgeGraphics = mapGraphics;
+        }
+        drawEdge(edges[edgeId], edgeGraphics);
+    }
+    drawOverlayLayers();
+    let bounds = simulatorContainer.getBounds();
+    simulatorContainer.pivot.set(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2);
+    simulatorContainer.position.set(renderer.width / 2, renderer.height / 2);
+    simulatorContainer.addChild(trafficLightContainer);
+
+    /**
+     * Settings for Cars
+     */
+    TURN_SIGNAL_LENGTH = CAR_LENGTH;
+    TURN_SIGNAL_WIDTH  = CAR_WIDTH / 2;
+
+    var carG = new Graphics();
+    carG.lineStyle(0);
+    carG.beginFill(0xFFFFFF, 0.8);
+    carG.drawRect(0, 0, CAR_LENGTH, CAR_WIDTH);
+
+    let carTexture = renderer.generateTexture(carG);
+
+    let signalG = new Graphics();
+    signalG.beginFill(TURN_SIGNAL_COLOR, 0.7).drawRect(0,0, TURN_SIGNAL_LENGTH, TURN_SIGNAL_WIDTH)
+           .drawRect(0, 3 * CAR_WIDTH - TURN_SIGNAL_WIDTH, TURN_SIGNAL_LENGTH, TURN_SIGNAL_WIDTH).endFill();
+    let turnSignalTexture = renderer.generateTexture(signalG);
+
+    let signalLeft = new Texture(turnSignalTexture, new Rectangle(0, 0, TURN_SIGNAL_LENGTH, CAR_WIDTH));
+    let signalStraight = new Texture(turnSignalTexture, new Rectangle(0, CAR_WIDTH, TURN_SIGNAL_LENGTH, CAR_WIDTH));
+    let signalRight = new Texture(turnSignalTexture, new Rectangle(0, CAR_WIDTH * 2, TURN_SIGNAL_LENGTH, CAR_WIDTH));
+    turnSignalTextures = [signalLeft, signalStraight, signalRight];
+
+
+    carPool = [];
+    if (debugMode)
+        carContainer = new Container();
+    else
+        carContainer = new ParticleContainer(NUM_CAR_POOL, {rotation: true, tint: true});
+
+
+    turnSignalContainer = new ParticleContainer(NUM_CAR_POOL, {rotation: true, tint: true});
+    simulatorContainer.addChild(carContainer);
+    simulatorContainer.addChild(turnSignalContainer);
+    for (let i = 0, len = NUM_CAR_POOL;i < len;++i) {
+        //var car = Sprite.fromImage("images/car.png")
+        let car = new Sprite(carTexture);
+        let signal = new Sprite(turnSignalTextures[1]);
+        car.anchor.set(1, 0.5);
+
+        if (debugMode) {
+            car.interactive = true;
+            car.on('mouseover', function () {
+                selectedDOM.innerText = car.name;
+                car.alpha = 0.8;
+            });
+            car.on('mouseout', function () {
+                // selectedDOM.innerText = "";
+                car.alpha = 1;
+            });
+        }
+        signal.anchor.set(1, 0.5);
+        carPool.push([car, signal]);
+    }
+    showCanvas();
+
+    return true;
+}
+
+function appendText(id, text) {
+    let p = document.createElement("span");
+    p.innerText = text;
+    document.getElementById("info").appendChild(p);
+    document.getElementById("info").appendChild(document.createElement("br"));
+}
+
+var statsFile = "";
+var withRange = false;
+var nodeStats, nodeRange;
+
+initCanvas();
+
+
+function transCoord(point) {
+    return [point[0], -point[1]];
+}
+
+function getDistrictColor(districtId) {
+    return DISTRICT_PALETTE[stringHash(districtId) % DISTRICT_PALETTE.length];
+}
+
+function cross2D(o, a, b) {
+    return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+}
+
+function convexHull(points) {
+    if (!points || points.length <= 2) return points ? points.slice() : [];
+    let sorted = points
+        .slice()
+        .sort((p, q) => (p.x === q.x ? p.y - q.y : p.x - q.x));
+    let lower = [];
+    for (let i = 0; i < sorted.length; ++i) {
+        while (lower.length >= 2 && cross2D(lower[lower.length - 2], lower[lower.length - 1], sorted[i]) <= 0) {
+            lower.pop();
+        }
+        lower.push(sorted[i]);
+    }
+    let upper = [];
+    for (let i = sorted.length - 1; i >= 0; --i) {
+        while (upper.length >= 2 && cross2D(upper[upper.length - 2], upper[upper.length - 1], sorted[i]) <= 0) {
+            upper.pop();
+        }
+        upper.push(sorted[i]);
+    }
+    lower.pop();
+    upper.pop();
+    return lower.concat(upper);
+}
+
+function drawDistrictRegionFills(graphics, districtToPoints) {
+    for (let districtId in districtToPoints) {
+        let pts = districtToPoints[districtId];
+        if (!pts || pts.length === 0) continue;
+        let color = getDistrictColor(districtId);
+        if (pts.length >= 3) {
+            let hull = convexHull(pts);
+            if (hull.length >= 3) {
+                graphics.lineStyle(1.2, color, 0.35);
+                graphics.beginFill(color, 0.11);
+                graphics.moveTo(hull[0].x, hull[0].y);
+                for (let i = 1; i < hull.length; ++i) {
+                    graphics.lineTo(hull[i].x, hull[i].y);
+                }
+                graphics.lineTo(hull[0].x, hull[0].y);
+                graphics.endFill();
+                continue;
+            }
+        }
+        if (pts.length === 2) {
+            graphics.lineStyle(18, color, 0.10);
+            graphics.drawLine(pts[0], pts[1]);
+            continue;
+        }
+        graphics.lineStyle(0);
+        graphics.beginFill(color, 0.12);
+        graphics.drawCircle(pts[0].x, pts[0].y, 18);
+        graphics.endFill();
+    }
+}
+
+function drawEdgePolyline(graphics, edge, width, color, alpha) {
+    graphics.lineStyle(width, color, alpha);
+    for (let i = 1; i < edge.points.length; ++i) {
+        graphics.drawLine(edge.points[i - 1], edge.points[i]);
+    }
+}
+
+function drawOverlayLayers() {
+    if (overlayContainer) {
+        overlayContainer.destroy(true);
+        overlayContainer = null;
+    }
+    if (!showDistrictOverlay && !showGatewayOverlay) {
+        return;
+    }
+    overlayContainer = new Container();
+    simulatorContainer.addChild(overlayContainer);
+
+    let overlayGraphics = new Graphics();
+    overlayContainer.addChild(overlayGraphics);
+
+    let intersectionToDistrict = {};
+    if (districtMap && districtMap.intersection_to_district) {
+        intersectionToDistrict = districtMap.intersection_to_district;
+    }
+    let gatewayNodeIds = new Set(
+        districtMap && districtMap.gateway_intersections
+            ? districtMap.gateway_intersections
+            : []
+    );
+    let gatewayEdgeIds = new Set(
+        districtMap && districtMap.gateway_roads
+            ? districtMap.gateway_roads
+            : []
+    );
+    let nodeDegree = {};
+    for (let edgeId in edges) {
+        let edge = edges[edgeId];
+        nodeDegree[edge.from.id] = (nodeDegree[edge.from.id] || 0) + 1;
+        nodeDegree[edge.to.id] = (nodeDegree[edge.to.id] || 0) + 1;
+    }
+    for (let nodeId in nodes) {
+        if ((nodeDegree[nodeId] || 0) <= 1) {
+            gatewayNodeIds.add(nodeId);
+        }
+    }
+
+    if (showDistrictOverlay && districtMap && districtMap.intersection_to_district) {
+        let districtToPoints = {};
+        for (let nodeId in nodes) {
+            let districtId = intersectionToDistrict[nodeId];
+            if (!districtId) continue;
+            if (!districtToPoints[districtId]) districtToPoints[districtId] = [];
+            districtToPoints[districtId].push(nodes[nodeId].point);
+        }
+        drawDistrictRegionFills(overlayGraphics, districtToPoints);
+
+        for (let edgeId in edges) {
+            let edge = edges[edgeId];
+            let fromDistrict = intersectionToDistrict[edge.from.id];
+            let toDistrict = intersectionToDistrict[edge.to.id];
+            if (!fromDistrict || !toDistrict) continue;
+            if (fromDistrict === toDistrict) {
+                drawEdgePolyline(
+                    overlayGraphics,
+                    edge,
+                    1.2,
+                    getDistrictColor(fromDistrict),
+                    0.45
+                );
+            } else {
+                drawEdgePolyline(
+                    overlayGraphics,
+                    edge,
+                    1.8,
+                    DISTRICT_BORDER_COLOR,
+                    0.8
+                );
+            }
+        }
+        for (let nodeId in nodes) {
+            let districtId = intersectionToDistrict[nodeId];
+            if (!districtId) continue;
+            let point = nodes[nodeId].point;
+            overlayGraphics.beginFill(getDistrictColor(districtId), 0.55);
+            overlayGraphics.drawCircle(point.x, point.y, 2.0);
+            overlayGraphics.endFill();
+        }
+    }
+
+    if (showGatewayOverlay) {
+        for (let edgeId in edges) {
+            let edge = edges[edgeId];
+            let fromGateway = gatewayNodeIds.has(edge.from.id) || String(edge.from.id).indexOf("g_") === 0;
+            let toGateway = gatewayNodeIds.has(edge.to.id) || String(edge.to.id).indexOf("g_") === 0;
+            let edgeLooksGateway = edgeId.indexOf("_g_") >= 0 || edgeId.indexOf("r_g_") === 0;
+            if (
+                gatewayEdgeIds.has(edgeId)
+                || fromGateway
+                || toGateway
+                || edgeLooksGateway
+            ) {
+                drawEdgePolyline(
+                    overlayGraphics,
+                    edge,
+                    5.6,
+                    GATEWAY_EDGE_COLOR,
+                    0.82
+                );
+            }
+        }
+        for (let nodeId in nodes) {
+            if (gatewayNodeIds.has(nodeId) || String(nodeId).indexOf("g_") === 0) {
+                let point = nodes[nodeId].point;
+                overlayGraphics.lineStyle(0);
+                overlayGraphics.beginFill(GATEWAY_NODE_COLOR, 0.28);
+                overlayGraphics.drawCircle(point.x, point.y, 34.0);
+                overlayGraphics.endFill();
+                overlayGraphics.lineStyle(2.2, 0x1f2d3d, 0.98);
+                overlayGraphics.beginFill(GATEWAY_NODE_COLOR, 0.96);
+                overlayGraphics.drawCircle(point.x, point.y, 13.0);
+                overlayGraphics.endFill();
+                overlayGraphics.lineStyle(0);
+                overlayGraphics.beginFill(0xffffff, 0.92);
+                overlayGraphics.drawCircle(point.x, point.y, 5.2);
+                overlayGraphics.endFill();
+            }
+        }
+    }
+}
+
+PIXI.Graphics.prototype.drawLine = function(pointA, pointB) {
+    this.moveTo(pointA.x, pointA.y);
+    this.lineTo(pointB.x, pointB.y);
+}
+
+PIXI.Graphics.prototype.drawDashLine = function(pointA, pointB, dash = 16, gap = 8) {
+    let direct = pointA.directTo(pointB);
+    let distance = pointA.distanceTo(pointB);
+
+    let currentPoint = pointA;
+    let currentDistance = 0;
+    let length;
+    let finish = false;
+    while (true) {
+        this.moveTo(currentPoint.x, currentPoint.y);
+        if (currentDistance + dash >= distance) {
+            length = distance - currentDistance;
+            finish = true;
+        } else {
+            length = dash
+        }
+        currentPoint = currentPoint.moveAlong(direct, length);
+        this.lineTo(currentPoint.x, currentPoint.y);
+        if (finish) break;
+        currentDistance += length;
+
+        if (currentDistance + gap >= distance) {
+            break;
+        } else {
+            currentPoint = currentPoint.moveAlong(direct, gap);
+            currentDistance += gap;
+        }
+    }
+};
+
+function drawNode(node, graphics) {
+    graphics.beginFill(LANE_COLOR);
+    let outline = node.outline;
+    for (let i = 0 ; i < outline.length ; i+=2) {
+        outline[i+1] = -outline[i+1];
+        if (i == 0)
+            graphics.moveTo(outline[i], outline[i+1]);
+        else
+            graphics.lineTo(outline[i], outline[i+1]);
+    }
+    graphics.endFill();
+
+    if (debugMode) {
+        graphics.hitArea = new PIXI.Polygon(outline);
+        graphics.interactive = true;
+        graphics.on("mouseover", function () {
+            selectedDOM.innerText = node.id;
+            graphics.alpha = 0.5;
+        });
+        graphics.on("mouseout", function () {
+            graphics.alpha = 1;
+        });
+    }
+
+}
+
+function drawEdge(edge, graphics) {
+    let from = edge.from;
+    let to = edge.to;
+    let points = edge.points;
+
+    let pointA, pointAOffset, pointB, pointBOffset;
+    let prevPointBOffset = null;
+
+    let roadWidth = 0;
+    edge.laneWidths.forEach(function(l){
+        roadWidth += l;
+    }, 0);
+
+    let coords = [], coords1 = [];
+
+    for (let i = 1;i < points.length;++i) {
+        if (i == 1){
+            pointA = points[0].moveAlongDirectTo(points[1], from.virtual ? 0 : from.width);
+            pointAOffset = points[0].directTo(points[1]).rotate(ROTATE);
+        } else {
+            pointA = points[i-1];
+            pointAOffset = prevPointBOffset;
+        }
+        if (i == points.length - 1) {
+            pointB = points[i].moveAlongDirectTo(points[i-1], to.virtual ? 0 : to.width);
+            pointBOffset = points[i-1].directTo(points[i]).rotate(ROTATE);
+        } else {
+            pointB = points[i];
+            pointBOffset = points[i-1].directTo(points[i+1]).rotate(ROTATE);
+        }
+        prevPointBOffset = pointBOffset;
+
+        lightG = new Graphics();
+        lightG.lineStyle(TRAFFIC_LIGHT_WIDTH, 0xFFFFFF);
+        lightG.drawLine(new Point(0, 0), new Point(1, 0));
+        lightTexture = renderer.generateTexture(lightG);
+
+        // Draw Traffic Lights
+        if (i == points.length-1 && !to.virtual) {
+            edgeTrafficLights = [];
+            prevOffset = offset = 0;
+            for (lane = 0;lane < edge.nLane;++lane) {
+                offset += edge.laneWidths[lane];
+                var light = new Sprite(lightTexture);
+                light.anchor.set(0, 0.5);
+                light.scale.set(offset - prevOffset, 1);
+                point_ = pointB.moveAlong(pointBOffset, prevOffset);
+                light.position.set(point_.x, point_.y);
+                light.rotation = pointBOffset.getAngleInRadians();
+                edgeTrafficLights.push(light);
+                prevOffset = offset;
+                trafficLightContainer.addChild(light);
+            }
+            trafficLightsG[edge.id] = edgeTrafficLights;
+        }
+
+        // Draw Roads
+        graphics.lineStyle(LANE_BORDER_WIDTH, LANE_BORDER_COLOR, 1);
+        graphics.drawLine(pointA, pointB);
+
+        pointA1 = pointA.moveAlong(pointAOffset, roadWidth);
+        pointB1 = pointB.moveAlong(pointBOffset, roadWidth);
+
+        graphics.lineStyle(0);
+        graphics.beginFill(LANE_COLOR);
+
+        coords = coords.concat([pointA.x, pointA.y, pointB.x, pointB.y]);
+        coords1 = coords1.concat([pointA1.y, pointA1.x, pointB1.y, pointB1.x]);
+
+        graphics.drawPolygon([pointA.x, pointA.y, pointB.x, pointB.y, pointB1.x, pointB1.y, pointA1.x, pointA1.y]);
+        graphics.endFill();
+
+        offset = 0;
+        for (let lane = 0, len = edge.nLane-1;lane < len;++lane) {
+            offset += edge.laneWidths[lane];
+            graphics.lineStyle(LANE_BORDER_WIDTH, LANE_INNER_COLOR);
+            graphics.drawDashLine(pointA.moveAlong(pointAOffset, offset), pointB.moveAlong(pointBOffset, offset), LANE_DASH, LANE_GAP);
+        }
+
+        offset += edge.laneWidths[edge.nLane-1];
+
+        // graphics.lineStyle(LANE_BORDER_WIDTH, LANE_BORDER_COLOR);
+        // graphics.drawLine(pointA.moveAlong(pointAOffset, offset), pointB.moveAlong(pointBOffset, offset));
+    }
+
+    if (debugMode) {
+        coords = coords.concat(coords1.reverse());
+        graphics.interactive = true;
+        graphics.hitArea = new PIXI.Polygon(coords);
+        graphics.on("mouseover", function () {
+            graphics.alpha = 0.5;
+            selectedDOM.innerText = edge.id;
+        });
+
+        graphics.on("mouseout", function () {
+            graphics.alpha = 1;
+        });
+    }
+}
+
+function run(delta) {
+    let redraw = false;
+
+    if (ready && (!controls.paused || redraw)) {
+        try {
+            drawStep(cnt);
+        }catch (e) {
+            infoAppend("Error occurred when drawing");
+            ready = false;
+        }
+        if (!controls.paused) {
+            frameElapsed += 1;
+            if (frameElapsed >= 1 / controls.replaySpeed ** 2) {
+                cnt += 1;
+                frameElapsed = 0;
+                if (cnt == totalStep) cnt = 0;
+            }
+        }
+    }
+}
+
+function _statusToColor(status) {
+    switch (status) {
+        case 'r':
+            return LIGHT_RED;
+        case 'g':
+            return LIGHT_GREEN;
+        default:
+            return 0x808080;  
+    }
+}
+
+function stringHash(str) {
+    let hash = 0;
+    let p = 127, p_pow = 1;
+    let m = 1e9 + 9;
+    for (let i = 0; i < str.length; i++) {
+        hash = (hash + str.charCodeAt(i) * p_pow) % m;
+        p_pow = (p_pow * p) % m;
+    }
+    return hash;
+}
+
+function drawStep(step) {
+    if (showChart && (step > chart.ptr || step == 0)) {
+        if (step == 0) {
+            chart.clear();
+        }
+        chart.ptr = step;
+        chart.addData(chartLog[step]);
+    }
+
+    let [carLogs, tlLogs] = logs[step].split(';');
+
+    tlLogs = tlLogs.split(',');
+    carLogs = carLogs.split(',');
+    
+    let tlLog, tlEdge, tlStatus;
+    for (let i = 0, len = tlLogs.length;i < len;++i) {
+        tlLog = tlLogs[i].split(' ');
+        tlEdge = tlLog[0];
+        tlStatus = tlLog.slice(1);
+        for (let j = 0, len = tlStatus.length;j < len;++j) {
+            trafficLightsG[tlEdge][j].tint = _statusToColor(tlStatus[j]);
+            if (tlStatus[j] == 'i' ) {
+                trafficLightsG[tlEdge][j].alpha = 0;
+            }else{
+                trafficLightsG[tlEdge][j].alpha = 1;
+            }
+        }
+    }
+
+    carContainer.removeChildren();
+    turnSignalContainer.removeChildren();
+    let carLog, position, length, width;
+    for (let i = 0, len = carLogs.length - 1;i < len;++i) {
+        carLog = carLogs[i].split(' ');
+        position = transCoord([parseFloat(carLog[0]), parseFloat(carLog[1])]);
+        length = parseFloat(carLog[5]);
+        width = parseFloat(carLog[6]);
+        carPool[i][0].position.set(position[0], position[1]);
+        carPool[i][0].rotation = 2*Math.PI - parseFloat(carLog[2]);
+        carPool[i][0].name = carLog[3];
+        let carColorId = stringHash(carLog[3]) % CAR_COLORS_NUM;
+        carPool[i][0].tint = CAR_COLORS[carColorId];
+        carPool[i][0].width = length;
+        carPool[i][0].height = width;
+        carContainer.addChild(carPool[i][0]);
+
+        let laneChange = parseInt(carLog[4]) + 1;
+        carPool[i][1].position.set(position[0], position[1]);
+        carPool[i][1].rotation = carPool[i][0].rotation;
+        carPool[i][1].texture = turnSignalTextures[laneChange];
+        carPool[i][1].width = length;
+        carPool[i][1].height = width;
+        turnSignalContainer.addChild(carPool[i][1]);
+    }
+    nodeCarNum.innerText = carLogs.length-1;
+    nodeTotalStep.innerText = totalStep;
+    nodeCurrentStep.innerText = cnt+1;
+    nodeProgressPercentage.innerText = (cnt / totalStep * 100).toFixed(2) + "%";
+    if (statsFile != "") {
+        if (withRange) nodeRange.value = stats[step][1];
+        nodeStats.innerText = stats[step][0].toFixed(2);
+    }
+}
+
+/*
+Chart
+ */
+let chart = {
+    max_steps: 3600,
+    data: {
+        labels: [],
+        series: [[]]
+    },
+    options: {
+        showPoint: false,
+        lineSmooth: false,
+        axisX: {
+            showGrid: false,
+            showLabel: false
+        }
+    },
+    init : function(title, series_cnt, max_step){
+        document.getElementById("chart-title").innerText = title;
+        this.max_steps = max_step;
+        this.data.labels = new Array(this.max_steps);
+        this.data.series = [];
+        for (let i = 0 ; i < series_cnt ; ++i)
+            this.data.series.push([]);
+        this.chart = new Chartist.Line('#chart', this.data, this.options);
+    },
+    addData: function (value) {
+        for (let i = 0 ; i < value.length; ++i) {
+            this.data.series[i].push(value[i]);
+            if (this.data.series[i].length > this.max_steps) {
+                this.data.series[i].shift();
+            }
+        }
+        this.chart.update();
+    },
+    clear: function() {
+        for (let i = 0 ; i < this.data.series.length ; ++i)
+            this.data.series[i] = [];
+    },
+    ptr: 0
+};

third_party/CityFlow/frontend/spinner.css

@@ -1,53 +1,53 @@
-/* https://tobiasahlin.com/spinkit/ */
-.spinner {
-  margin: 100px auto;
-  width: 50px;
-  height: 40px;
-  text-align: center;
-  font-size: 10px;
-}
-
-.spinner > div {
-  background-color: #333;
-  height: 100%;
-  width: 6px;
-  display: inline-block;
-  
-  -webkit-animation: sk-stretchdelay 1.2s infinite ease-in-out;
-  animation: sk-stretchdelay 1.2s infinite ease-in-out;
-}
-
-.spinner .rect2 {
-  -webkit-animation-delay: -1.1s;
-  animation-delay: -1.1s;
-}
-
-.spinner .rect3 {
-  -webkit-animation-delay: -1.0s;
-  animation-delay: -1.0s;
-}
-
-.spinner .rect4 {
-  -webkit-animation-delay: -0.9s;
-  animation-delay: -0.9s;
-}
-
-.spinner .rect5 {
-  -webkit-animation-delay: -0.8s;
-  animation-delay: -0.8s;
-}
-
-@-webkit-keyframes sk-stretchdelay {
-  0%, 40%, 100% { -webkit-transform: scaleY(0.4) }  
-  20% { -webkit-transform: scaleY(1.0) }
-}
-
-@keyframes sk-stretchdelay {
-  0%, 40%, 100% { 
-    transform: scaleY(0.4);
-    -webkit-transform: scaleY(0.4);
-  }  20% { 
-    transform: scaleY(1.0);
-    -webkit-transform: scaleY(1.0);
-  }
+/* https://tobiasahlin.com/spinkit/ */
+.spinner {
+  margin: 100px auto;
+  width: 50px;
+  height: 40px;
+  text-align: center;
+  font-size: 10px;
+}
+
+.spinner > div {
+  background-color: #333;
+  height: 100%;
+  width: 6px;
+  display: inline-block;
+  
+  -webkit-animation: sk-stretchdelay 1.2s infinite ease-in-out;
+  animation: sk-stretchdelay 1.2s infinite ease-in-out;
+}
+
+.spinner .rect2 {
+  -webkit-animation-delay: -1.1s;
+  animation-delay: -1.1s;
+}
+
+.spinner .rect3 {
+  -webkit-animation-delay: -1.0s;
+  animation-delay: -1.0s;
+}
+
+.spinner .rect4 {
+  -webkit-animation-delay: -0.9s;
+  animation-delay: -0.9s;
+}
+
+.spinner .rect5 {
+  -webkit-animation-delay: -0.8s;
+  animation-delay: -0.8s;
+}
+
+@-webkit-keyframes sk-stretchdelay {
+  0%, 40%, 100% { -webkit-transform: scaleY(0.4) }  
+  20% { -webkit-transform: scaleY(1.0) }
+}
+
+@keyframes sk-stretchdelay {
+  0%, 40%, 100% { 
+    transform: scaleY(0.4);
+    -webkit-transform: scaleY(0.4);
+  }  20% { 
+    transform: scaleY(1.0);
+    -webkit-transform: scaleY(1.0);
+  }
 }

third_party/CityFlow/frontend/style.css

@@ -1,64 +1,64 @@
-html, body {
-    margin: 0;
-    padding: 0;
-    height: 100%;
-    width: 100%;
-    overflow: hidden;
-}
-
-.noselect {
-    -webkit-touch-callout: none;
-    -webkit-user-select: none;
-    -khtml-user-select: none;
-    -moz-user-select: none;
-    -ms-user-select: none;
-    user-select: none;
-}
-
-#simulator-canvas {
-    marigin: 0;
-    padding: 0;
-    height: 100%;
-    width: 100%;
-    overflow: hidden;
-}
-
-.status-panel {
-    z-index: 3;
-    height: 100vh;
-    overflow-y: auto;
-}
-
-#info {
-    max-height: 100%;
-}
-
-#chart {
-    height: 100%;
-}
-
-#chart .ct-line {
-    stroke-width: 1px;
-    stroke-opacity: 0.8;
-}
-
-#chart .ct-label {
-    font-weight: bold;
-}
-
-#chart-container {
-    background-color: rgba(216, 220, 225, 0.8);
-    position: absolute;
-    bottom: 0;
-    right: 0;
-    left: 0;
-    box-sizing: border-box;
-}
-
-#chart-title {
-    font-weight: bold;
-    font-size: large;
-    color: #6c757d;
-    width: 100%;
-    text-align: center;
+html, body {
+    margin: 0;
+    padding: 0;
+    height: 100%;
+    width: 100%;
+    overflow: hidden;
+}
+
+.noselect {
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
+
+#simulator-canvas {
+    marigin: 0;
+    padding: 0;
+    height: 100%;
+    width: 100%;
+    overflow: hidden;
+}
+
+.status-panel {
+    z-index: 3;
+    height: 100vh;
+    overflow-y: auto;
+}
+
+#info {
+    max-height: 100%;
+}
+
+#chart {
+    height: 100%;
+}
+
+#chart .ct-line {
+    stroke-width: 1px;
+    stroke-opacity: 0.8;
+}
+
+#chart .ct-label {
+    font-weight: bold;
+}
+
+#chart-container {
+    background-color: rgba(216, 220, 225, 0.8);
+    position: absolute;
+    bottom: 0;
+    right: 0;
+    left: 0;
+    box-sizing: border-box;
+}
+
+#chart-title {
+    font-weight: bold;
+    font-size: large;
+    color: #6c757d;
+    width: 100%;
+    text-align: center;
 }

third_party/CityFlow/frontend/style_multi.css

@@ -1,747 +1,747 @@
-/* =========================================================
-   Traffic Visualizer – Multi-Panel Dashboard Styles
-   ========================================================= */
-
-*, *::before, *::after { box-sizing: border-box; }
-
-body {
-  margin: 0;
-  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
-  background: #1a1d23;
-  color: #d4d8e0;
-  height: 100vh;
-  overflow: hidden;
-  display: flex;
-}
-
-/* ── Sidebar ──────────────────────────────────────────── */
-#sidebar {
-  width: 270px;
-  min-width: 180px;
-  background: #22252e;
-  border-right: 1px solid #333744;
-  display: flex;
-  flex-direction: column;
-  overflow-y: auto;
-  padding: 16px;
-  gap: 16px;
-  z-index: 10;
-  scrollbar-width: thin;
-  scrollbar-color: #3a4055 transparent;
-}
-#sidebar::-webkit-scrollbar { width: 5px; }
-#sidebar::-webkit-scrollbar-track { background: transparent; }
-#sidebar::-webkit-scrollbar-thumb { background: #3a4055; border-radius: 3px; }
-#sidebar::-webkit-scrollbar-thumb:hover { background: #5b6cf9; }
-
-#sidebar h1 {
-  font-size: 18px;
-  font-weight: 700;
-  color: #fff;
-  margin: 0 0 4px 0;
-  letter-spacing: 0.5px;
-}
-
-#sidebar .subtitle {
-  font-size: 11px;
-  color: #777e90;
-  margin: 0;
-}
-
-.sidebar-section {
-  background: #1a1d23;
-  border-radius: 8px;
-  padding: 12px;
-  border: 1px solid #2e3240;
-}
-
-.sidebar-section h3 {
-  font-size: 11px;
-  font-weight: 600;
-  text-transform: uppercase;
-  letter-spacing: 1px;
-  color: #777e90;
-  margin: 0 0 10px 0;
-}
-
-/* File upload zone */
-#roadnet-drop-zone {
-  border: 2px dashed #3a4055;
-  border-radius: 6px;
-  padding: 20px 12px;
-  text-align: center;
-  cursor: pointer;
-  transition: border-color 0.2s, background 0.2s;
-  font-size: 13px;
-  color: #777e90;
-}
-#roadnet-drop-zone:hover,
-#roadnet-drop-zone.drag-over {
-  border-color: #5b6cf9;
-  background: rgba(91, 108, 249, 0.06);
-  color: #aab0c2;
-}
-#roadnet-drop-zone .drop-icon {
-  font-size: 24px;
-  margin-bottom: 6px;
-  display: block;
-}
-#roadnet-drop-zone .drop-filename {
-  font-size: 12px;
-  color: #5b6cf9;
-  font-weight: 600;
-  margin-top: 4px;
-}
-#roadnet-file-input { display: none; }
-
-/* City/Scenario pickers */
-.picker-row {
-  display: flex;
-  flex-direction: column;
-  gap: 6px;
-}
-.picker-row label {
-  font-size: 11px;
-  color: #777e90;
-  font-weight: 600;
-  text-transform: uppercase;
-  letter-spacing: 0.5px;
-}
-.picker-row select {
-  width: 100%;
-  background: #22252e;
-  border: 1px solid #3a4055;
-  color: #d4d8e0;
-  border-radius: 5px;
-  padding: 6px 8px;
-  font-size: 13px;
-  outline: none;
-  cursor: pointer;
-}
-.picker-row select:focus {
-  border-color: #5b6cf9;
-}
-.picker-row select:disabled {
-  opacity: 0.4;
-  cursor: not-allowed;
-}
-
-/* Policy checkboxes */
-.policy-list {
-  display: flex;
-  flex-direction: column;
-  gap: 7px;
-}
-.policy-item {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  cursor: pointer;
-  user-select: none;
-}
-.policy-item input[type="checkbox"] {
-  accent-color: var(--policy-color);
-  width: 15px;
-  height: 15px;
-  cursor: pointer;
-}
-.policy-item.disabled {
-  opacity: 0.4;
-  cursor: not-allowed;
-}
-.policy-item.disabled input { cursor: not-allowed; }
-
-.policy-badge {
-  display: inline-block;
-  width: 10px;
-  height: 10px;
-  border-radius: 50%;
-  flex-shrink: 0;
-}
-.policy-label {
-  font-size: 13px;
-  flex: 1;
-}
-.policy-tag {
-  font-size: 10px;
-  background: rgba(255,255,255,0.07);
-  color: #888;
-  border-radius: 3px;
-  padding: 1px 5px;
-}
-
-.recent-runs-list {
-  display: flex;
-  flex-direction: column;
-  gap: 8px;
-}
-.recent-run-empty {
-  font-size: 12px;
-  color: #777e90;
-}
-.recent-run-card {
-  border: 1px solid #323747;
-  border-radius: 7px;
-  background: #22252e;
-  padding: 9px 10px;
-  display: flex;
-  flex-direction: column;
-  gap: 6px;
-}
-.recent-run-top {
-  display: flex;
-  justify-content: space-between;
-  gap: 8px;
-  align-items: baseline;
-}
-.recent-run-title {
-  font-size: 12px;
-  font-weight: 700;
-  color: #e7ecf4;
-}
-.recent-run-time {
-  font-size: 10px;
-  color: #7f8a9d;
-  white-space: nowrap;
-}
-.recent-run-meta {
-  font-size: 11px;
-  color: #aab4c4;
-}
-.recent-run-policies {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 4px;
-}
-.recent-run-chip {
-  font-size: 10px;
-  color: #dbe2ee;
-  background: rgba(255,255,255,0.08);
-  border: 1px solid rgba(255,255,255,0.08);
-  border-radius: 999px;
-  padding: 2px 6px;
-}
-
-.debug-log {
-  max-height: 180px;
-  overflow: auto;
-  padding: 10px;
-  border-radius: 8px;
-  background: #161a22;
-  border: 1px solid #2c3442;
-  color: #dbe4ff;
-  font: 12px/1.45 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
-  white-space: pre-wrap;
-}
-.recent-run-actions {
-  display: flex;
-  gap: 6px;
-}
-.recent-run-btn {
-  flex: 1;
-  background: #2b3040;
-  border: 1px solid #40475d;
-  color: #dce3ef;
-  border-radius: 5px;
-  padding: 5px 7px;
-  font-size: 11px;
-  cursor: pointer;
-}
-.recent-run-btn:hover {
-  border-color: #5b6cf9;
-}
-
-/* View mode selector */
-.view-mode-row {
-  display: flex;
-  gap: 6px;
-}
-.view-mode-btn {
-  flex: 1;
-  background: #22252e;
-  border: 1px solid #3a4055;
-  color: #777e90;
-  border-radius: 5px;
-  padding: 6px 0;
-  font-size: 12px;
-  font-weight: 600;
-  cursor: pointer;
-  transition: all 0.15s;
-  text-align: center;
-}
-.view-mode-btn:hover { border-color: #5b6cf9; color: #aab0c2; }
-.view-mode-btn.active {
-  background: #5b6cf9;
-  border-color: #5b6cf9;
-  color: #fff;
-}
-
-/* Run button */
-#run-btn {
-  width: 100%;
-  padding: 10px;
-  background: linear-gradient(135deg, #5b6cf9, #7c3aed);
-  color: #fff;
-  border: none;
-  border-radius: 6px;
-  font-size: 14px;
-  font-weight: 600;
-  cursor: pointer;
-  transition: opacity 0.2s, transform 0.1s;
-  letter-spacing: 0.3px;
-}
-#run-btn:hover { opacity: 0.9; }
-#run-btn:active { transform: scale(0.98); }
-#run-btn:disabled { opacity: 0.4; cursor: not-allowed; }
-
-/* Force-rerun checkbox */
-.force-rerun-row {
-  display: flex;
-  align-items: center;
-  gap: 7px;
-  font-size: 11px;
-  color: #777e90;
-  cursor: pointer;
-  user-select: none;
-  margin-top: 2px;
-}
-.force-rerun-row input[type="checkbox"] {
-  accent-color: #5b6cf9;
-  width: 13px;
-  height: 13px;
-  cursor: pointer;
-}
-
-/* Progress */
-#progress-section { display: none; }
-
-.progress-policy-row {
-  padding: 6px 0;
-  border-bottom: 1px solid #2e3240;
-}
-.progress-policy-row:last-child { border-bottom: none; }
-
-.progress-policy-top {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  margin-bottom: 5px;
-}
-.progress-policy-dot {
-  width: 8px;
-  height: 8px;
-  border-radius: 50%;
-  flex-shrink: 0;
-}
-.progress-policy-name { flex: 1; font-size: 12px; color: #d4d8e0; }
-.progress-policy-pct {
-  font-size: 11px;
-  font-variant-numeric: tabular-nums;
-  color: #777e90;
-  min-width: 36px;
-  text-align: right;
-}
-.progress-policy-pct.done  { color: #10b981; }
-.progress-policy-pct.error { color: #ef4444; }
-
-.progress-policy-bar-track {
-  height: 4px;
-  background: #2e3240;
-  border-radius: 2px;
-  overflow: hidden;
-}
-.progress-policy-bar-fill {
-  height: 100%;
-  border-radius: 2px;
-  width: 0%;
-  transition: width 0.15s ease;
-}
-
-/* Sidebar resize handle */
-#sidebar-resize-handle {
-  width: 4px;
-  min-width: 4px;
-  background: #2e3240;
-  cursor: col-resize;
-  transition: background 0.15s;
-  z-index: 10;
-  flex-shrink: 0;
-}
-#sidebar-resize-handle:hover,
-#sidebar-resize-handle.dragging {
-  background: #5b6cf9;
-}
-
-/* ── Main area ────────────────────────────────────────── */
-#main {
-  flex: 1;
-  display: flex;
-  flex-direction: column;
-  overflow: hidden;
-}
-
-/* Playback toolbar */
-#playback-bar {
-  background: #22252e;
-  border-bottom: 1px solid #333744;
-  padding: 8px 16px;
-  display: flex;
-  align-items: center;
-  gap: 12px;
-  flex-shrink: 0;
-}
-#playback-bar button {
-  background: #2e3240;
-  border: 1px solid #3a4055;
-  color: #d4d8e0;
-  border-radius: 5px;
-  padding: 5px 14px;
-  font-size: 13px;
-  cursor: pointer;
-  transition: background 0.15s;
-}
-#playback-bar button:hover { background: #3a4055; }
-#playback-bar button:disabled { opacity: 0.4; cursor: not-allowed; }
-
-#summary-bar {
-  background: #1c2028;
-  border-bottom: 1px solid #2c3341;
-  padding: 10px 12px;
-  display: flex;
-  gap: 10px;
-  overflow-x: auto;
-  flex-shrink: 0;
-}
-
-.summary-empty {
-  color: #8d97aa;
-  font-size: 13px;
-}
-
-.summary-card {
-  min-width: 245px;
-  background: #222733;
-  border: 1px solid #313949;
-  border-top: 3px solid var(--summary-color, #5b6cf9);
-  border-radius: 10px;
-  padding: 10px 12px;
-  display: flex;
-  flex-direction: column;
-  gap: 8px;
-}
-
-.summary-card-header {
-  display: flex;
-  justify-content: space-between;
-  align-items: baseline;
-  gap: 8px;
-}
-
-.summary-card-title {
-  font-size: 13px;
-  font-weight: 700;
-  color: #edf2ff;
-}
-
-.summary-card-subtitle {
-  font-size: 10px;
-  color: #9aa4b8;
-  text-transform: uppercase;
-  letter-spacing: 0.08em;
-}
-
-.summary-grid {
-  display: grid;
-  grid-template-columns: 1fr 1fr;
-  gap: 6px 10px;
-}
-
-.summary-stat-label {
-  font-size: 10px;
-  color: #8893a8;
-  text-transform: uppercase;
-  letter-spacing: 0.08em;
-}
-
-.summary-stat-value {
-  font-size: 13px;
-  color: #f5f7fb;
-  font-weight: 600;
-}
-
-.summary-delta {
-  font-size: 11px;
-  font-weight: 600;
-}
-
-.summary-delta.good { color: #34d399; }
-.summary-delta.bad { color: #f87171; }
-.summary-delta.neutral { color: #94a3b8; }
-
-#scrubber {
-  flex: 1;
-  accent-color: #5b6cf9;
-  cursor: pointer;
-}
-#step-display {
-  font-size: 12px;
-  color: #777e90;
-  font-variant-numeric: tabular-nums;
-  min-width: 90px;
-  text-align: right;
-}
-#speed-label {
-  font-size: 12px;
-  color: #777e90;
-  min-width: 48px;
-}
-
-/* Panel grid */
-#panels-container {
-  flex: 1;
-  overflow: hidden;
-  display: grid;
-  gap: 2px;
-  background: #111318;
-}
-
-/* Grid layouts */
-#panels-container.layout-1 {
-  grid-template-columns: 1fr;
-  grid-template-rows: 1fr;
-}
-#panels-container.layout-2 {
-  grid-template-columns: 1fr 1fr;
-  grid-template-rows: 1fr;
-}
-#panels-container.layout-3 {
-  grid-template-columns: 1fr 1fr 1fr;
-  grid-template-rows: 1fr;
-}
-#panels-container.layout-6 {
-  grid-template-columns: 1fr 1fr 1fr;
-  grid-template-rows: 1fr 1fr;
-}
-
-/* Individual panel */
-.sim-panel {
-  position: relative;
-  background: #f5f0e8;
-  overflow: hidden;
-  display: flex;
-  flex-direction: column;
-}
-
-.panel-header {
-  position: absolute;
-  top: 8px;
-  left: 8px;
-  right: 8px;
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  z-index: 5;
-  pointer-events: none;
-}
-.panel-policy-dot {
-  width: 10px;
-  height: 10px;
-  border-radius: 50%;
-  flex-shrink: 0;
-}
-.panel-policy-name {
-  font-size: 12px;
-  font-weight: 700;
-  letter-spacing: 0.5px;
-}
-/* Dark background box wrapping dot + policy name */
-.panel-label-box {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  background: rgba(0, 0, 0, 0.72);
-  backdrop-filter: blur(4px);
-  border-radius: 6px;
-  padding: 4px 8px;
-  pointer-events: none;
-}
-/* Per-panel zoom controls */
-.panel-zoom-controls {
-  display: flex;
-  gap: 3px;
-  pointer-events: auto;
-  margin-left: auto;
-}
-.panel-zoom-btn {
-  background: rgba(0,0,0,0.45);
-  backdrop-filter: blur(4px);
-  border: 1px solid rgba(255,255,255,0.15);
-  color: #e0dbd2;
-  border-radius: 4px;
-  width: 22px;
-  height: 22px;
-  font-size: 14px;
-  line-height: 1;
-  cursor: pointer;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  transition: background 0.15s;
-}
-.panel-zoom-btn:hover { background: rgba(0,0,0,0.65); }
-
-/* Per-panel metrics overlay (bottom-left of canvas) */
-.panel-metrics-overlay {
-  position: absolute;
-  bottom: 8px;
-  left: 8px;
-  z-index: 5;
-  background: rgba(0, 0, 0, 0.72);
-  backdrop-filter: blur(4px);
-  border-radius: 6px;
-  padding: 5px 9px;
-  pointer-events: none;
-  display: flex;
-  flex-direction: column;
-  gap: 2px;
-}
-.pmo-row {
-  display: flex;
-  justify-content: space-between;
-  gap: 14px;
-  font-size: 10px;
-}
-.pmo-label { color: #9ea8b8; }
-.pmo-value { color: #e2ddd6; font-variant-numeric: tabular-nums; }
-
-.panel-map-legend {
-  position: absolute;
-  right: 8px;
-  bottom: 8px;
-  z-index: 5;
-  background: rgba(0, 0, 0, 0.72);
-  backdrop-filter: blur(4px);
-  border-radius: 6px;
-  padding: 6px 8px;
-  pointer-events: none;
-  display: flex;
-  flex-direction: column;
-  gap: 3px;
-  min-width: 108px;
-}
-.panel-map-legend.hidden { display: none; }
-.panel-map-legend-title {
-  font-size: 9px;
-  color: #b8c1cf;
-  text-transform: uppercase;
-  letter-spacing: 0.08em;
-  font-weight: 700;
-  margin-bottom: 1px;
-}
-.panel-map-legend-row {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  font-size: 10px;
-  color: #e2ddd6;
-}
-.panel-map-swatch {
-  display: inline-block;
-  width: 18px;
-  height: 8px;
-  border-radius: 999px;
-  flex-shrink: 0;
-}
-.panel-map-swatch.districts {
-  background: rgba(95, 172, 248, 0.55);
-  border: 1px solid rgba(95, 172, 248, 0.8);
-}
-.panel-map-swatch.entry { background: #22c55e; }
-.panel-map-swatch.exit { background: #ef4444; }
-.panel-map-swatch.gateway { background: #f39c12; }
-
-.panel-canvas-wrapper {
-  flex: 1;
-  position: relative;
-}
-.panel-canvas-wrapper canvas {
-  display: block;
-  width: 100% !important;
-  height: 100% !important;
-}
-
-/* Coming-soon overlay for LLM+DQN */
-.coming-soon-overlay {
-  position: absolute;
-  inset: 0;
-  background: rgba(17,19,24,0.88);
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  gap: 8px;
-  z-index: 10;
-}
-.coming-soon-overlay .cs-icon { font-size: 36px; }
-.coming-soon-overlay .cs-title {
-  font-size: 15px;
-  font-weight: 700;
-  color: #fff;
-}
-.coming-soon-overlay .cs-sub {
-  font-size: 12px;
-  color: #777e90;
-}
-
-/* Panel loading spinner */
-.panel-spinner {
-  position: absolute;
-  inset: 0;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  background: #f5f0e8;
-  z-index: 8;
-}
-.panel-spinner.hidden { display: none; }
-.spinner-ring {
-  width: 36px;
-  height: 36px;
-  border: 3px solid #d4c9b8;
-  border-top-color: #5b6cf9;
-  border-radius: 50%;
-  animation: spin 0.8s linear infinite;
-}
-@keyframes spin { to { transform: rotate(360deg); } }
-
-/* Welcome / idle state */
-#welcome-overlay {
-  position: absolute;
-  inset: 0;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  background: #f5f0e8;
-  z-index: 20;
-  flex-direction: column;
-  gap: 10px;
-  text-align: center;
-}
-#welcome-overlay h2 { font-size: 20px; color: #2e2820; margin: 0; }
-#welcome-overlay p { font-size: 13px; color: #7a6e60; margin: 0; max-width: 320px; }
-#welcome-overlay.hidden { display: none; }
-
-/* Policy color variables */
-:root {
-  --color-no-intervention: #94a3b8;
-  --color-fixed:           #f59e0b;
-  --color-random:          #10b981;
-  --color-learned:         #5b6cf9;
-  --color-llm-dqn:         #ec4899;
-  --color-dqn-heuristic:   #06b6d4;
-}
-
-/* Responsive: if viewport too narrow, collapse sidebar */
-@media (max-width: 600px) {
-  #sidebar { width: 200px; min-width: 200px; }
-}
+/* =========================================================
+   Traffic Visualizer – Multi-Panel Dashboard Styles
+   ========================================================= */
+
+*, *::before, *::after { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  background: #1a1d23;
+  color: #d4d8e0;
+  height: 100vh;
+  overflow: hidden;
+  display: flex;
+}
+
+/* ── Sidebar ──────────────────────────────────────────── */
+#sidebar {
+  width: 270px;
+  min-width: 180px;
+  background: #22252e;
+  border-right: 1px solid #333744;
+  display: flex;
+  flex-direction: column;
+  overflow-y: auto;
+  padding: 16px;
+  gap: 16px;
+  z-index: 10;
+  scrollbar-width: thin;
+  scrollbar-color: #3a4055 transparent;
+}
+#sidebar::-webkit-scrollbar { width: 5px; }
+#sidebar::-webkit-scrollbar-track { background: transparent; }
+#sidebar::-webkit-scrollbar-thumb { background: #3a4055; border-radius: 3px; }
+#sidebar::-webkit-scrollbar-thumb:hover { background: #5b6cf9; }
+
+#sidebar h1 {
+  font-size: 18px;
+  font-weight: 700;
+  color: #fff;
+  margin: 0 0 4px 0;
+  letter-spacing: 0.5px;
+}
+
+#sidebar .subtitle {
+  font-size: 11px;
+  color: #777e90;
+  margin: 0;
+}
+
+.sidebar-section {
+  background: #1a1d23;
+  border-radius: 8px;
+  padding: 12px;
+  border: 1px solid #2e3240;
+}
+
+.sidebar-section h3 {
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 1px;
+  color: #777e90;
+  margin: 0 0 10px 0;
+}
+
+/* File upload zone */
+#roadnet-drop-zone {
+  border: 2px dashed #3a4055;
+  border-radius: 6px;
+  padding: 20px 12px;
+  text-align: center;
+  cursor: pointer;
+  transition: border-color 0.2s, background 0.2s;
+  font-size: 13px;
+  color: #777e90;
+}
+#roadnet-drop-zone:hover,
+#roadnet-drop-zone.drag-over {
+  border-color: #5b6cf9;
+  background: rgba(91, 108, 249, 0.06);
+  color: #aab0c2;
+}
+#roadnet-drop-zone .drop-icon {
+  font-size: 24px;
+  margin-bottom: 6px;
+  display: block;
+}
+#roadnet-drop-zone .drop-filename {
+  font-size: 12px;
+  color: #5b6cf9;
+  font-weight: 600;
+  margin-top: 4px;
+}
+#roadnet-file-input { display: none; }
+
+/* City/Scenario pickers */
+.picker-row {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+.picker-row label {
+  font-size: 11px;
+  color: #777e90;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+.picker-row select {
+  width: 100%;
+  background: #22252e;
+  border: 1px solid #3a4055;
+  color: #d4d8e0;
+  border-radius: 5px;
+  padding: 6px 8px;
+  font-size: 13px;
+  outline: none;
+  cursor: pointer;
+}
+.picker-row select:focus {
+  border-color: #5b6cf9;
+}
+.picker-row select:disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+
+/* Policy checkboxes */
+.policy-list {
+  display: flex;
+  flex-direction: column;
+  gap: 7px;
+}
+.policy-item {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  cursor: pointer;
+  user-select: none;
+}
+.policy-item input[type="checkbox"] {
+  accent-color: var(--policy-color);
+  width: 15px;
+  height: 15px;
+  cursor: pointer;
+}
+.policy-item.disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+.policy-item.disabled input { cursor: not-allowed; }
+
+.policy-badge {
+  display: inline-block;
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+.policy-label {
+  font-size: 13px;
+  flex: 1;
+}
+.policy-tag {
+  font-size: 10px;
+  background: rgba(255,255,255,0.07);
+  color: #888;
+  border-radius: 3px;
+  padding: 1px 5px;
+}
+
+.recent-runs-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.recent-run-empty {
+  font-size: 12px;
+  color: #777e90;
+}
+.recent-run-card {
+  border: 1px solid #323747;
+  border-radius: 7px;
+  background: #22252e;
+  padding: 9px 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+.recent-run-top {
+  display: flex;
+  justify-content: space-between;
+  gap: 8px;
+  align-items: baseline;
+}
+.recent-run-title {
+  font-size: 12px;
+  font-weight: 700;
+  color: #e7ecf4;
+}
+.recent-run-time {
+  font-size: 10px;
+  color: #7f8a9d;
+  white-space: nowrap;
+}
+.recent-run-meta {
+  font-size: 11px;
+  color: #aab4c4;
+}
+.recent-run-policies {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+}
+.recent-run-chip {
+  font-size: 10px;
+  color: #dbe2ee;
+  background: rgba(255,255,255,0.08);
+  border: 1px solid rgba(255,255,255,0.08);
+  border-radius: 999px;
+  padding: 2px 6px;
+}
+
+.debug-log {
+  max-height: 180px;
+  overflow: auto;
+  padding: 10px;
+  border-radius: 8px;
+  background: #161a22;
+  border: 1px solid #2c3442;
+  color: #dbe4ff;
+  font: 12px/1.45 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  white-space: pre-wrap;
+}
+.recent-run-actions {
+  display: flex;
+  gap: 6px;
+}
+.recent-run-btn {
+  flex: 1;
+  background: #2b3040;
+  border: 1px solid #40475d;
+  color: #dce3ef;
+  border-radius: 5px;
+  padding: 5px 7px;
+  font-size: 11px;
+  cursor: pointer;
+}
+.recent-run-btn:hover {
+  border-color: #5b6cf9;
+}
+
+/* View mode selector */
+.view-mode-row {
+  display: flex;
+  gap: 6px;
+}
+.view-mode-btn {
+  flex: 1;
+  background: #22252e;
+  border: 1px solid #3a4055;
+  color: #777e90;
+  border-radius: 5px;
+  padding: 6px 0;
+  font-size: 12px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.15s;
+  text-align: center;
+}
+.view-mode-btn:hover { border-color: #5b6cf9; color: #aab0c2; }
+.view-mode-btn.active {
+  background: #5b6cf9;
+  border-color: #5b6cf9;
+  color: #fff;
+}
+
+/* Run button */
+#run-btn {
+  width: 100%;
+  padding: 10px;
+  background: linear-gradient(135deg, #5b6cf9, #7c3aed);
+  color: #fff;
+  border: none;
+  border-radius: 6px;
+  font-size: 14px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: opacity 0.2s, transform 0.1s;
+  letter-spacing: 0.3px;
+}
+#run-btn:hover { opacity: 0.9; }
+#run-btn:active { transform: scale(0.98); }
+#run-btn:disabled { opacity: 0.4; cursor: not-allowed; }
+
+/* Force-rerun checkbox */
+.force-rerun-row {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  font-size: 11px;
+  color: #777e90;
+  cursor: pointer;
+  user-select: none;
+  margin-top: 2px;
+}
+.force-rerun-row input[type="checkbox"] {
+  accent-color: #5b6cf9;
+  width: 13px;
+  height: 13px;
+  cursor: pointer;
+}
+
+/* Progress */
+#progress-section { display: none; }
+
+.progress-policy-row {
+  padding: 6px 0;
+  border-bottom: 1px solid #2e3240;
+}
+.progress-policy-row:last-child { border-bottom: none; }
+
+.progress-policy-top {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 5px;
+}
+.progress-policy-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+.progress-policy-name { flex: 1; font-size: 12px; color: #d4d8e0; }
+.progress-policy-pct {
+  font-size: 11px;
+  font-variant-numeric: tabular-nums;
+  color: #777e90;
+  min-width: 36px;
+  text-align: right;
+}
+.progress-policy-pct.done  { color: #10b981; }
+.progress-policy-pct.error { color: #ef4444; }
+
+.progress-policy-bar-track {
+  height: 4px;
+  background: #2e3240;
+  border-radius: 2px;
+  overflow: hidden;
+}
+.progress-policy-bar-fill {
+  height: 100%;
+  border-radius: 2px;
+  width: 0%;
+  transition: width 0.15s ease;
+}
+
+/* Sidebar resize handle */
+#sidebar-resize-handle {
+  width: 4px;
+  min-width: 4px;
+  background: #2e3240;
+  cursor: col-resize;
+  transition: background 0.15s;
+  z-index: 10;
+  flex-shrink: 0;
+}
+#sidebar-resize-handle:hover,
+#sidebar-resize-handle.dragging {
+  background: #5b6cf9;
+}
+
+/* ── Main area ────────────────────────────────────────── */
+#main {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+/* Playback toolbar */
+#playback-bar {
+  background: #22252e;
+  border-bottom: 1px solid #333744;
+  padding: 8px 16px;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-shrink: 0;
+}
+#playback-bar button {
+  background: #2e3240;
+  border: 1px solid #3a4055;
+  color: #d4d8e0;
+  border-radius: 5px;
+  padding: 5px 14px;
+  font-size: 13px;
+  cursor: pointer;
+  transition: background 0.15s;
+}
+#playback-bar button:hover { background: #3a4055; }
+#playback-bar button:disabled { opacity: 0.4; cursor: not-allowed; }
+
+#summary-bar {
+  background: #1c2028;
+  border-bottom: 1px solid #2c3341;
+  padding: 10px 12px;
+  display: flex;
+  gap: 10px;
+  overflow-x: auto;
+  flex-shrink: 0;
+}
+
+.summary-empty {
+  color: #8d97aa;
+  font-size: 13px;
+}
+
+.summary-card {
+  min-width: 245px;
+  background: #222733;
+  border: 1px solid #313949;
+  border-top: 3px solid var(--summary-color, #5b6cf9);
+  border-radius: 10px;
+  padding: 10px 12px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.summary-card-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  gap: 8px;
+}
+
+.summary-card-title {
+  font-size: 13px;
+  font-weight: 700;
+  color: #edf2ff;
+}
+
+.summary-card-subtitle {
+  font-size: 10px;
+  color: #9aa4b8;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+}
+
+.summary-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 6px 10px;
+}
+
+.summary-stat-label {
+  font-size: 10px;
+  color: #8893a8;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+}
+
+.summary-stat-value {
+  font-size: 13px;
+  color: #f5f7fb;
+  font-weight: 600;
+}
+
+.summary-delta {
+  font-size: 11px;
+  font-weight: 600;
+}
+
+.summary-delta.good { color: #34d399; }
+.summary-delta.bad { color: #f87171; }
+.summary-delta.neutral { color: #94a3b8; }
+
+#scrubber {
+  flex: 1;
+  accent-color: #5b6cf9;
+  cursor: pointer;
+}
+#step-display {
+  font-size: 12px;
+  color: #777e90;
+  font-variant-numeric: tabular-nums;
+  min-width: 90px;
+  text-align: right;
+}
+#speed-label {
+  font-size: 12px;
+  color: #777e90;
+  min-width: 48px;
+}
+
+/* Panel grid */
+#panels-container {
+  flex: 1;
+  overflow: hidden;
+  display: grid;
+  gap: 2px;
+  background: #111318;
+}
+
+/* Grid layouts */
+#panels-container.layout-1 {
+  grid-template-columns: 1fr;
+  grid-template-rows: 1fr;
+}
+#panels-container.layout-2 {
+  grid-template-columns: 1fr 1fr;
+  grid-template-rows: 1fr;
+}
+#panels-container.layout-3 {
+  grid-template-columns: 1fr 1fr 1fr;
+  grid-template-rows: 1fr;
+}
+#panels-container.layout-6 {
+  grid-template-columns: 1fr 1fr 1fr;
+  grid-template-rows: 1fr 1fr;
+}
+
+/* Individual panel */
+.sim-panel {
+  position: relative;
+  background: #f5f0e8;
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+}
+
+.panel-header {
+  position: absolute;
+  top: 8px;
+  left: 8px;
+  right: 8px;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  z-index: 5;
+  pointer-events: none;
+}
+.panel-policy-dot {
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+.panel-policy-name {
+  font-size: 12px;
+  font-weight: 700;
+  letter-spacing: 0.5px;
+}
+/* Dark background box wrapping dot + policy name */
+.panel-label-box {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  background: rgba(0, 0, 0, 0.72);
+  backdrop-filter: blur(4px);
+  border-radius: 6px;
+  padding: 4px 8px;
+  pointer-events: none;
+}
+/* Per-panel zoom controls */
+.panel-zoom-controls {
+  display: flex;
+  gap: 3px;
+  pointer-events: auto;
+  margin-left: auto;
+}
+.panel-zoom-btn {
+  background: rgba(0,0,0,0.45);
+  backdrop-filter: blur(4px);
+  border: 1px solid rgba(255,255,255,0.15);
+  color: #e0dbd2;
+  border-radius: 4px;
+  width: 22px;
+  height: 22px;
+  font-size: 14px;
+  line-height: 1;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: background 0.15s;
+}
+.panel-zoom-btn:hover { background: rgba(0,0,0,0.65); }
+
+/* Per-panel metrics overlay (bottom-left of canvas) */
+.panel-metrics-overlay {
+  position: absolute;
+  bottom: 8px;
+  left: 8px;
+  z-index: 5;
+  background: rgba(0, 0, 0, 0.72);
+  backdrop-filter: blur(4px);
+  border-radius: 6px;
+  padding: 5px 9px;
+  pointer-events: none;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+.pmo-row {
+  display: flex;
+  justify-content: space-between;
+  gap: 14px;
+  font-size: 10px;
+}
+.pmo-label { color: #9ea8b8; }
+.pmo-value { color: #e2ddd6; font-variant-numeric: tabular-nums; }
+
+.panel-map-legend {
+  position: absolute;
+  right: 8px;
+  bottom: 8px;
+  z-index: 5;
+  background: rgba(0, 0, 0, 0.72);
+  backdrop-filter: blur(4px);
+  border-radius: 6px;
+  padding: 6px 8px;
+  pointer-events: none;
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  min-width: 108px;
+}
+.panel-map-legend.hidden { display: none; }
+.panel-map-legend-title {
+  font-size: 9px;
+  color: #b8c1cf;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  font-weight: 700;
+  margin-bottom: 1px;
+}
+.panel-map-legend-row {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 10px;
+  color: #e2ddd6;
+}
+.panel-map-swatch {
+  display: inline-block;
+  width: 18px;
+  height: 8px;
+  border-radius: 999px;
+  flex-shrink: 0;
+}
+.panel-map-swatch.districts {
+  background: rgba(95, 172, 248, 0.55);
+  border: 1px solid rgba(95, 172, 248, 0.8);
+}
+.panel-map-swatch.entry { background: #22c55e; }
+.panel-map-swatch.exit { background: #ef4444; }
+.panel-map-swatch.gateway { background: #f39c12; }
+
+.panel-canvas-wrapper {
+  flex: 1;
+  position: relative;
+}
+.panel-canvas-wrapper canvas {
+  display: block;
+  width: 100% !important;
+  height: 100% !important;
+}
+
+/* Coming-soon overlay for LLM+DQN */
+.coming-soon-overlay {
+  position: absolute;
+  inset: 0;
+  background: rgba(17,19,24,0.88);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  z-index: 10;
+}
+.coming-soon-overlay .cs-icon { font-size: 36px; }
+.coming-soon-overlay .cs-title {
+  font-size: 15px;
+  font-weight: 700;
+  color: #fff;
+}
+.coming-soon-overlay .cs-sub {
+  font-size: 12px;
+  color: #777e90;
+}
+
+/* Panel loading spinner */
+.panel-spinner {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: #f5f0e8;
+  z-index: 8;
+}
+.panel-spinner.hidden { display: none; }
+.spinner-ring {
+  width: 36px;
+  height: 36px;
+  border: 3px solid #d4c9b8;
+  border-top-color: #5b6cf9;
+  border-radius: 50%;
+  animation: spin 0.8s linear infinite;
+}
+@keyframes spin { to { transform: rotate(360deg); } }
+
+/* Welcome / idle state */
+#welcome-overlay {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: #f5f0e8;
+  z-index: 20;
+  flex-direction: column;
+  gap: 10px;
+  text-align: center;
+}
+#welcome-overlay h2 { font-size: 20px; color: #2e2820; margin: 0; }
+#welcome-overlay p { font-size: 13px; color: #7a6e60; margin: 0; max-width: 320px; }
+#welcome-overlay.hidden { display: none; }
+
+/* Policy color variables */
+:root {
+  --color-no-intervention: #94a3b8;
+  --color-fixed:           #f59e0b;
+  --color-random:          #10b981;
+  --color-learned:         #5b6cf9;
+  --color-llm-dqn:         #ec4899;
+  --color-dqn-heuristic:   #06b6d4;
+}
+
+/* Responsive: if viewport too narrow, collapse sidebar */
+@media (max-width: 600px) {
+  #sidebar { width: 200px; min-width: 200px; }
+}

third_party/CityFlow/setup.py

@@ -1,70 +1,70 @@
-import os
-import re
-import sys
-import platform
-import subprocess
-
-from setuptools import setup, Extension
-from setuptools.command.build_ext import build_ext
-from distutils.version import LooseVersion
-
-
-class CMakeExtension(Extension):
-    def __init__(self, name, sourcedir=''):
-        Extension.__init__(self, name, sources=[])
-        self.sourcedir = os.path.abspath(sourcedir)
-
-
-class CMakeBuild(build_ext):
-    def run(self):
-        try:
-            out = subprocess.check_output(['cmake', '--version'])
-        except OSError:
-            raise RuntimeError("CMake must be installed to build the following extensions: " +
-                               ", ".join(e.name for e in self.extensions))
-
-        if platform.system() == "Windows":
-            cmake_version = LooseVersion(re.search(r'version\s*([\d.]+)', out.decode()).group(1))
-            if cmake_version < '3.1.0':
-                raise RuntimeError("CMake >= 3.1.0 is required on Windows")
-
-        for ext in self.extensions:
-            self.build_extension(ext)
-
-    def build_extension(self, ext):
-        extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name)))
-        cmake_args = ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir,
-                      '-DPYTHON_EXECUTABLE=' + sys.executable,
-                      '-DVERSION="' + self.distribution.get_version() + '"']
-
-        cfg = 'Debug' if self.debug else 'Release'
-        build_args = ['--config', cfg]
-
-        if platform.system() == "Windows":
-            cmake_args += ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}'.format(cfg.upper(), extdir)]
-            if sys.maxsize > 2**32:
-                cmake_args += ['-A', 'x64']
-            build_args += ['--', '/m']
-        else:
-            cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg]
-            build_args += ['--', '-j2']
-
-        env = os.environ.copy()
-
-        if not os.path.exists(self.build_temp):
-            os.makedirs(self.build_temp)
-        subprocess.check_call(['cmake', ext.sourcedir] + cmake_args, cwd=self.build_temp, env=env)
-        subprocess.check_call(['cmake', '--build', '.', '--target', 'cityflow'] + build_args, cwd=self.build_temp)
-
-
-setup(
-    name='CityFlow',
-    version='0.1',
-    author='Huichu Zhang',
-    author_email='zhc@apex.sjtu.edu.cn',
-    description='CityFlow: A Multi-Agent Reinforcement Learning Environment for Large Scale City Traffic Scenario',
-    long_description='',
-    ext_modules=[CMakeExtension('cityflow')],
-    cmdclass=dict(build_ext=CMakeBuild),
-    zip_safe=False
-)
+import os
+import re
+import sys
+import platform
+import subprocess
+
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+from distutils.version import LooseVersion
+
+
+class CMakeExtension(Extension):
+    def __init__(self, name, sourcedir=''):
+        Extension.__init__(self, name, sources=[])
+        self.sourcedir = os.path.abspath(sourcedir)
+
+
+class CMakeBuild(build_ext):
+    def run(self):
+        try:
+            out = subprocess.check_output(['cmake', '--version'])
+        except OSError:
+            raise RuntimeError("CMake must be installed to build the following extensions: " +
+                               ", ".join(e.name for e in self.extensions))
+
+        if platform.system() == "Windows":
+            cmake_version = LooseVersion(re.search(r'version\s*([\d.]+)', out.decode()).group(1))
+            if cmake_version < '3.1.0':
+                raise RuntimeError("CMake >= 3.1.0 is required on Windows")
+
+        for ext in self.extensions:
+            self.build_extension(ext)
+
+    def build_extension(self, ext):
+        extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name)))
+        cmake_args = ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir,
+                      '-DPYTHON_EXECUTABLE=' + sys.executable,
+                      '-DVERSION="' + self.distribution.get_version() + '"']
+
+        cfg = 'Debug' if self.debug else 'Release'
+        build_args = ['--config', cfg]
+
+        if platform.system() == "Windows":
+            cmake_args += ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}'.format(cfg.upper(), extdir)]
+            if sys.maxsize > 2**32:
+                cmake_args += ['-A', 'x64']
+            build_args += ['--', '/m']
+        else:
+            cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg]
+            build_args += ['--', '-j2']
+
+        env = os.environ.copy()
+
+        if not os.path.exists(self.build_temp):
+            os.makedirs(self.build_temp)
+        subprocess.check_call(['cmake', ext.sourcedir] + cmake_args, cwd=self.build_temp, env=env)
+        subprocess.check_call(['cmake', '--build', '.', '--target', 'cityflow'] + build_args, cwd=self.build_temp)
+
+
+setup(
+    name='CityFlow',
+    version='0.1',
+    author='Huichu Zhang',
+    author_email='zhc@apex.sjtu.edu.cn',
+    description='CityFlow: A Multi-Agent Reinforcement Learning Environment for Large Scale City Traffic Scenario',
+    long_description='',
+    ext_modules=[CMakeExtension('cityflow')],
+    cmdclass=dict(build_ext=CMakeBuild),
+    zip_safe=False
+)

third_party/CityFlow/src/CMakeLists.txt

@@ -1,36 +1,36 @@
-set(PROJECT_HEADER_FILES
-    utility/config.h
-    utility/utility.h
-    utility/barrier.h
-    utility/optionparser.h
-    engine/archive.h
-    engine/engine.h
-    flow/flow.h
-    flow/route.h
-    roadnet/roadnet.h
-    roadnet/trafficlight.h
-    vehicle/router.h
-    vehicle/vehicle.h
-    vehicle/lanechange.h
-)
-
-set(PROJECT_SOURCE_FILES
-    utility/utility.cpp
-    utility/barrier.cpp
-    engine/archive.cpp
-    engine/engine.cpp
-    flow/flow.cpp
-    roadnet/roadnet.cpp
-    roadnet/trafficlight.cpp
-    vehicle/router.cpp
-    vehicle/vehicle.cpp
-    vehicle/lanechange.cpp)
-
-set(PROJECT_LIB_NAME ${PROJECT_NAME}_lib CACHE INTERNAL "")
-
-find_package(Threads REQUIRED)
-
-add_library(${PROJECT_LIB_NAME} ${PROJECT_HEADER_FILES} ${PROJECT_SOURCE_FILES})
-set_target_properties(${PROJECT_LIB_NAME} PROPERTIES CXX_VISIBILITY_PRESET "hidden")
-target_link_libraries(${PROJECT_LIB_NAME} PRIVATE Threads::Threads)
+set(PROJECT_HEADER_FILES
+    utility/config.h
+    utility/utility.h
+    utility/barrier.h
+    utility/optionparser.h
+    engine/archive.h
+    engine/engine.h
+    flow/flow.h
+    flow/route.h
+    roadnet/roadnet.h
+    roadnet/trafficlight.h
+    vehicle/router.h
+    vehicle/vehicle.h
+    vehicle/lanechange.h
+)
+
+set(PROJECT_SOURCE_FILES
+    utility/utility.cpp
+    utility/barrier.cpp
+    engine/archive.cpp
+    engine/engine.cpp
+    flow/flow.cpp
+    roadnet/roadnet.cpp
+    roadnet/trafficlight.cpp
+    vehicle/router.cpp
+    vehicle/vehicle.cpp
+    vehicle/lanechange.cpp)
+
+set(PROJECT_LIB_NAME ${PROJECT_NAME}_lib CACHE INTERNAL "")
+
+find_package(Threads REQUIRED)
+
+add_library(${PROJECT_LIB_NAME} ${PROJECT_HEADER_FILES} ${PROJECT_SOURCE_FILES})
+set_target_properties(${PROJECT_LIB_NAME} PROPERTIES CXX_VISIBILITY_PRESET "hidden")
+target_link_libraries(${PROJECT_LIB_NAME} PRIVATE Threads::Threads)
 target_include_directories(${PROJECT_LIB_NAME} PUBLIC ${CMAKE_CURRENT_LIST_DIR})

third_party/CityFlow/src/cityflow.cpp

@@ -1,48 +1,48 @@
-#include "engine/engine.h"
-#include "engine/archive.h"
-
-#include "pybind11/pybind11.h"
-#include "pybind11/stl.h"
-
-namespace py = pybind11;
-using namespace py::literals;
-
-PYBIND11_MODULE(cityflow, m) {
-    py::class_<CityFlow::Engine>(m, "Engine")
-        .def(py::init<const std::string&, int>(),
-            "config_file"_a,
-            "thread_num"_a=1
-        )
-        .def("next_step", &CityFlow::Engine::nextStep)
-        .def("get_vehicle_count", &CityFlow::Engine::getVehicleCount)
-        .def("get_vehicles", &CityFlow::Engine::getVehicles, "include_waiting"_a=false)
-        .def("get_lane_vehicle_count", &CityFlow::Engine::getLaneVehicleCount)
-        .def("get_lane_waiting_vehicle_count", &CityFlow::Engine::getLaneWaitingVehicleCount)
-        .def("get_lane_vehicles", &CityFlow::Engine::getLaneVehicles)
-        .def("get_vehicle_speed", &CityFlow::Engine::getVehicleSpeed)
-        .def("get_vehicle_info", &CityFlow::Engine::getVehicleInfo, "vehicle_id"_a)
-        .def("get_vehicle_distance", &CityFlow::Engine::getVehicleDistance)
-        .def("get_leader", &CityFlow::Engine::getLeader, "vehicle_id"_a)
-        .def("get_current_time", &CityFlow::Engine::getCurrentTime)
-        .def("get_average_travel_time", &CityFlow::Engine::getAverageTravelTime)
-        .def("set_tl_phase", &CityFlow::Engine::setTrafficLightPhase, "intersection_id"_a, "phase_id"_a)
-        .def("set_vehicle_speed", &CityFlow::Engine::setVehicleSpeed, "vehicle_id"_a, "speed"_a)
-        .def("set_replay_file", &CityFlow::Engine::setReplayLogFile, "replay_file"_a)
-        .def("set_random_seed", &CityFlow::Engine::setRandomSeed, "seed"_a)
-        .def("set_save_replay", &CityFlow::Engine::setSaveReplay, "open"_a)
-        .def("push_vehicle", (void (CityFlow::Engine::*)(const std::map<std::string, double>&, const std::vector<std::string>&)) &CityFlow::Engine::pushVehicle)
-        .def("reset", &CityFlow::Engine::reset, "seed"_a=false)
-        .def("load", &CityFlow::Engine::load, "archive"_a)
-        .def("snapshot", &CityFlow::Engine::snapshot)
-        .def("load_from_file", &CityFlow::Engine::loadFromFile, "path"_a)
-        .def("set_vehicle_route", &CityFlow::Engine::setRoute, "vehicle_id"_a, "route"_a);
-
-    py::class_<CityFlow::Archive>(m, "Archive")
-        .def(py::init<const CityFlow::Engine&>())
-        .def("dump", &CityFlow::Archive::dump, "path"_a);
-#ifdef VERSION
-    m.attr("__version__") = VERSION;
-#else
-    m.attr("__version__") = "dev";
-#endif
+#include "engine/engine.h"
+#include "engine/archive.h"
+
+#include "pybind11/pybind11.h"
+#include "pybind11/stl.h"
+
+namespace py = pybind11;
+using namespace py::literals;
+
+PYBIND11_MODULE(cityflow, m) {
+    py::class_<CityFlow::Engine>(m, "Engine")
+        .def(py::init<const std::string&, int>(),
+            "config_file"_a,
+            "thread_num"_a=1
+        )
+        .def("next_step", &CityFlow::Engine::nextStep)
+        .def("get_vehicle_count", &CityFlow::Engine::getVehicleCount)
+        .def("get_vehicles", &CityFlow::Engine::getVehicles, "include_waiting"_a=false)
+        .def("get_lane_vehicle_count", &CityFlow::Engine::getLaneVehicleCount)
+        .def("get_lane_waiting_vehicle_count", &CityFlow::Engine::getLaneWaitingVehicleCount)
+        .def("get_lane_vehicles", &CityFlow::Engine::getLaneVehicles)
+        .def("get_vehicle_speed", &CityFlow::Engine::getVehicleSpeed)
+        .def("get_vehicle_info", &CityFlow::Engine::getVehicleInfo, "vehicle_id"_a)
+        .def("get_vehicle_distance", &CityFlow::Engine::getVehicleDistance)
+        .def("get_leader", &CityFlow::Engine::getLeader, "vehicle_id"_a)
+        .def("get_current_time", &CityFlow::Engine::getCurrentTime)
+        .def("get_average_travel_time", &CityFlow::Engine::getAverageTravelTime)
+        .def("set_tl_phase", &CityFlow::Engine::setTrafficLightPhase, "intersection_id"_a, "phase_id"_a)
+        .def("set_vehicle_speed", &CityFlow::Engine::setVehicleSpeed, "vehicle_id"_a, "speed"_a)
+        .def("set_replay_file", &CityFlow::Engine::setReplayLogFile, "replay_file"_a)
+        .def("set_random_seed", &CityFlow::Engine::setRandomSeed, "seed"_a)
+        .def("set_save_replay", &CityFlow::Engine::setSaveReplay, "open"_a)
+        .def("push_vehicle", (void (CityFlow::Engine::*)(const std::map<std::string, double>&, const std::vector<std::string>&)) &CityFlow::Engine::pushVehicle)
+        .def("reset", &CityFlow::Engine::reset, "seed"_a=false)
+        .def("load", &CityFlow::Engine::load, "archive"_a)
+        .def("snapshot", &CityFlow::Engine::snapshot)
+        .def("load_from_file", &CityFlow::Engine::loadFromFile, "path"_a)
+        .def("set_vehicle_route", &CityFlow::Engine::setRoute, "vehicle_id"_a, "route"_a);
+
+    py::class_<CityFlow::Archive>(m, "Archive")
+        .def(py::init<const CityFlow::Engine&>())
+        .def("dump", &CityFlow::Archive::dump, "path"_a);
+#ifdef VERSION
+    m.attr("__version__") = VERSION;
+#else
+    m.attr("__version__") = "dev";
+#endif
 }

third_party/CityFlow/tests/CMakeLists.txt

@@ -1,14 +1,14 @@
-file(GLOB TEST_SRCS cpp/*.cpp)
-set(FLAGS "-fsanitize=address -fno-omit-frame-pointer")
-include_directories(${GTEST_INCLUDE_DIRS})
-foreach(SRC_PATH ${TEST_SRCS})
-    get_filename_component(SRC_NAME ${SRC_PATH} NAME)
-    string(REPLACE ".cpp" "" EXE_NAME ${SRC_NAME})
-    add_executable(${EXE_NAME} ${SRC_PATH})
-    set_target_properties(${EXE_NAME} PROPERTIES APPEND_STRING PROPERTY LINK_FLAGS "${FLAGS}")
-    set_target_properties(${EXE_NAME} PROPERTIES APPEND_STRING PROPERTY COMPILE_FLAGS "${FLAGS}")
-    target_link_libraries(${EXE_NAME} PUBLIC ${PROJECT_LIB_NAME} ${GTEST_BOTH_LIBRARIES})
-    add_test(NAME ${EXE_NAME}
-            WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-            COMMAND ${EXE_NAME})
+file(GLOB TEST_SRCS cpp/*.cpp)
+set(FLAGS "-fsanitize=address -fno-omit-frame-pointer")
+include_directories(${GTEST_INCLUDE_DIRS})
+foreach(SRC_PATH ${TEST_SRCS})
+    get_filename_component(SRC_NAME ${SRC_PATH} NAME)
+    string(REPLACE ".cpp" "" EXE_NAME ${SRC_NAME})
+    add_executable(${EXE_NAME} ${SRC_PATH})
+    set_target_properties(${EXE_NAME} PROPERTIES APPEND_STRING PROPERTY LINK_FLAGS "${FLAGS}")
+    set_target_properties(${EXE_NAME} PROPERTIES APPEND_STRING PROPERTY COMPILE_FLAGS "${FLAGS}")
+    target_link_libraries(${EXE_NAME} PUBLIC ${PROJECT_LIB_NAME} ${GTEST_BOTH_LIBRARIES})
+    add_test(NAME ${EXE_NAME}
+            WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+            COMMAND ${EXE_NAME})
 endforeach()

third_party/CityFlow/tools/debug/CMakeLists.txt

@@ -1,9 +1,9 @@
-set(SOURCE_FILES simple_run.cpp)
-
-foreach(SRC_PATH ${SOURCE_FILES})
-    get_filename_component(SRC_NAME ${SRC_PATH} NAME)
-    string(REPLACE ".cpp" "" EXE_NAME ${SRC_NAME})
-    add_executable(${EXE_NAME} ${SRC_PATH})
-    set_target_properties(${EXE_NAME} PROPERTIES CXX_VISIBILITY_PRESET "hidden")
-    target_link_libraries(${EXE_NAME} PRIVATE ${PROJECT_LIB_NAME})
+set(SOURCE_FILES simple_run.cpp)
+
+foreach(SRC_PATH ${SOURCE_FILES})
+    get_filename_component(SRC_NAME ${SRC_PATH} NAME)
+    string(REPLACE ".cpp" "" EXE_NAME ${SRC_NAME})
+    add_executable(${EXE_NAME} ${SRC_PATH})
+    set_target_properties(${EXE_NAME} PROPERTIES CXX_VISIBILITY_PRESET "hidden")
+    target_link_libraries(${EXE_NAME} PRIVATE ${PROJECT_LIB_NAME})
 endforeach()

third_party/CityFlow/tools/debug/simple_run.cpp

@@ -1,59 +1,59 @@
-#include "engine/engine.h"
-#include "utility/optionparser.h"
-
-#include <string>
-#include <iostream>
-#include <cstdlib>
-#include <ctime>
-
-using namespace CityFlow;
-
-int main(int argc, char const *argv[]) {
-    optionparser::OptionParser parser;
-
-    parser.add_option("--configFile", "-c")
-            .help("config file")
-            .mode(optionparser::StorageMode::STORE_VALUE)
-            .required(true);
-
-    parser.add_option("--totalStep", "-s")
-            .help("simulation steps")
-            .default_value(1000)
-            .mode(optionparser::StorageMode::STORE_VALUE);
-
-    parser.add_option("--threadNum", "-t")
-            .help("number of threads")
-            .default_value(1)
-            .mode(optionparser::StorageMode::STORE_VALUE);
-
-    parser.add_option("--verbose", "-v")
-            .help("be verbose")
-            .mode(optionparser::StorageMode::STORE_TRUE);
-
-    parser.eat_arguments(argc, argv);
-    std::string configFile = parser.get_value<std::string>("configFile");
-    bool verbose = parser.get_value("verbose");
-    size_t totalStep = parser.get_value<int>("totalStep");
-    size_t threadNum = parser.get_value<int>("threadNum");
-
-    std::string dataDir(std::getenv("DATADIR"));
-
-    Engine engine(dataDir + configFile, (size_t) threadNum);
-    time_t startTime, endTime;
-    time(&startTime);
-    for (int i = 0; i < totalStep; i++) {
-        if (verbose) {
-            std::cout << i << " " << engine.getVehicleCount() << std::endl;
-        }
-        engine.nextStep();
-        //engine.getVehicleSpeed();
-        //engine.getLaneVehicles();
-        //engine.getLaneWaitingVehicleCount();
-        //engine.getVehicleDistance();
-        //engine.getCurrentTime();
-    }
-    time(&endTime);
-    std::cout << "Total Step: " << totalStep << std::endl;
-    std::cout << "Total Time: " << (endTime - startTime) << "s" << std::endl;
-    return 0;
+#include "engine/engine.h"
+#include "utility/optionparser.h"
+
+#include <string>
+#include <iostream>
+#include <cstdlib>
+#include <ctime>
+
+using namespace CityFlow;
+
+int main(int argc, char const *argv[]) {
+    optionparser::OptionParser parser;
+
+    parser.add_option("--configFile", "-c")
+            .help("config file")
+            .mode(optionparser::StorageMode::STORE_VALUE)
+            .required(true);
+
+    parser.add_option("--totalStep", "-s")
+            .help("simulation steps")
+            .default_value(1000)
+            .mode(optionparser::StorageMode::STORE_VALUE);
+
+    parser.add_option("--threadNum", "-t")
+            .help("number of threads")
+            .default_value(1)
+            .mode(optionparser::StorageMode::STORE_VALUE);
+
+    parser.add_option("--verbose", "-v")
+            .help("be verbose")
+            .mode(optionparser::StorageMode::STORE_TRUE);
+
+    parser.eat_arguments(argc, argv);
+    std::string configFile = parser.get_value<std::string>("configFile");
+    bool verbose = parser.get_value("verbose");
+    size_t totalStep = parser.get_value<int>("totalStep");
+    size_t threadNum = parser.get_value<int>("threadNum");
+
+    std::string dataDir(std::getenv("DATADIR"));
+
+    Engine engine(dataDir + configFile, (size_t) threadNum);
+    time_t startTime, endTime;
+    time(&startTime);
+    for (int i = 0; i < totalStep; i++) {
+        if (verbose) {
+            std::cout << i << " " << engine.getVehicleCount() << std::endl;
+        }
+        engine.nextStep();
+        //engine.getVehicleSpeed();
+        //engine.getLaneVehicles();
+        //engine.getLaneWaitingVehicleCount();
+        //engine.getVehicleDistance();
+        //engine.getCurrentTime();
+    }
+    time(&endTime);
+    std::cout << "Total Step: " << totalStep << std::endl;
+    std::cout << "Total Time: " << (endTime - startTime) << "s" << std::endl;
+    return 0;
 }

third_party/CityFlow/tools/generator/generate_grid_scenario.py

@@ -1,127 +1,127 @@
-import argparse
-import json
-import os
-from generate_json_from_grid import gridToRoadnet
-
-def parse_args():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("rowNum", type=int)
-    parser.add_argument("colNum", type=int)
-    parser.add_argument("--rowDistance", type=int, default=300)
-    parser.add_argument("--columnDistance", type=int, default=300)
-    parser.add_argument("--intersectionWidth", type=int, default=30)
-    parser.add_argument("--numLeftLanes", type=int, default=1)
-    parser.add_argument("--numStraightLanes", type=int, default=1)
-    parser.add_argument("--numRightLanes", type=int, default=1)
-    parser.add_argument("--laneMaxSpeed", type=float, default=16.67)
-    parser.add_argument("--vehLen", type=float, default=5.0)
-    parser.add_argument("--vehWidth", type=float, default=2.0)
-    parser.add_argument("--vehMaxPosAcc", type=float, default=2.0)
-    parser.add_argument("--vehMaxNegAcc", type=float, default=4.5)
-    parser.add_argument("--vehUsualPosAcc", type=float, default=2.0)
-    parser.add_argument("--vehUsualNegAcc", type=float, default=4.5)
-    parser.add_argument("--vehMinGap", type=float, default=2.5)
-    parser.add_argument("--vehMaxSpeed", type=float, default=16.67)
-    parser.add_argument("--vehHeadwayTime", type=float, default=1.5)
-    parser.add_argument("--dir", type=str, default="./")
-    parser.add_argument("--roadnetFile", type=str)
-    parser.add_argument("--turn", action="store_true")
-    parser.add_argument("--tlPlan", action="store_true")
-    parser.add_argument("--interval", type=float, default=2.0)
-    parser.add_argument("--flowFile", type=str)
-    return parser.parse_args()
-
-def generate_route(rowNum, colNum, turn=False):
-    routes = []
-    move = [(1, 0), (0, 1), (-1, 0), (0, -1)]
-
-    def get_straight_route(start, direction, step):
-        x, y = start
-        route = []
-        for _ in range(step):
-            route.append("road_%d_%d_%d" % (x, y, direction))
-            x += move[direction][0]
-            y += move[direction][1]
-        return route
-
-    for i in range(1, rowNum+1):
-        routes.append(get_straight_route((0, i), 0, colNum+1))
-        routes.append(get_straight_route((colNum+1, i), 2, colNum+1))
-    for i in range(1, colNum+1):
-        routes.append(get_straight_route((i, 0), 1, rowNum+1))
-        routes.append(get_straight_route((i, rowNum+1), 3, rowNum+1))
-    
-    if turn:
-        def get_turn_route(start, direction):
-            if direction[0] % 2 == 0:
-                step = min(rowNum*2, colNum*2+1)
-            else:
-                step = min(colNum*2, rowNum*2+1)
-            x, y = start
-            route = []
-            cur = 0
-            for _ in range(step):
-                route.append("road_%d_%d_%d" % (x, y, direction[cur]))
-                x += move[direction[cur]][0]
-                y += move[direction[cur]][1]
-                cur = 1 - cur
-            return route
-
-        routes.append(get_turn_route((1, 0), (1, 0)))
-        routes.append(get_turn_route((0, 1), (0, 1)))
-        routes.append(get_turn_route((colNum+1, rowNum), (2, 3)))
-        routes.append(get_turn_route((colNum, rowNum+1), (3, 2)))
-        routes.append(get_turn_route((0, rowNum), (0, 3)))
-        routes.append(get_turn_route((1, rowNum+1), (3, 0)))
-        routes.append(get_turn_route((colNum+1, 1), (2, 1)))
-        routes.append(get_turn_route((colNum, 0), (1, 2)))
-    
-    return routes
-
-if __name__ == '__main__':
-    args = parse_args()
-    if args.roadnetFile is None:
-        args.roadnetFile = "roadnet_%d_%d%s.json" % (args.rowNum, args.colNum, "_turn" if args.turn else "")
-    if args.flowFile is None:
-        args.flowFile = "flow_%d_%d%s.json" % (args.rowNum, args.colNum, "_turn" if args.turn else "")
-
-    grid = {
-        "rowNumber": args.rowNum,
-        "columnNumber": args.colNum,
-        "rowDistances": [args.rowDistance] * (args.colNum-1),
-        "columnDistances": [args.columnDistance] * (args.rowNum-1),
-        "outRowDistance": args.rowDistance,
-        "outColumnDistance": args.columnDistance,
-        "intersectionWidths": [[args.intersectionWidth] * args.colNum] * args.rowNum,
-        "numLeftLanes": args.numLeftLanes,
-        "numStraightLanes": args.numStraightLanes,
-        "numRightLanes": args.numRightLanes,
-        "laneMaxSpeed": args.laneMaxSpeed,
-        "tlPlan": args.tlPlan
-    }
-
-    json.dump(gridToRoadnet(**grid), open(os.path.join(args.dir, args.roadnetFile), "w"), indent=2)
-    
-    vehicle_template = {
-        "length": args.vehLen,
-        "width": args.vehWidth,
-        "maxPosAcc": args.vehMaxPosAcc,
-        "maxNegAcc": args.vehMaxNegAcc,
-        "usualPosAcc": args.vehUsualPosAcc,
-        "usualNegAcc": args.vehUsualNegAcc,
-        "minGap": args.vehMinGap,
-        "maxSpeed": args.vehMaxSpeed,
-        "headwayTime": args.vehHeadwayTime
-    }
-    routes = generate_route(args.rowNum, args.colNum, args.turn)
-    flow = []
-    for route in routes:
-        flow.append({
-            "vehicle": vehicle_template,
-            "route": route,
-            "interval": args.interval,
-            "startTime": 0,
-            "endTime": -1
-        })
-    json.dump(flow, open(os.path.join(args.dir, args.flowFile), "w"), indent=2)
-
+import argparse
+import json
+import os
+from generate_json_from_grid import gridToRoadnet
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("rowNum", type=int)
+    parser.add_argument("colNum", type=int)
+    parser.add_argument("--rowDistance", type=int, default=300)
+    parser.add_argument("--columnDistance", type=int, default=300)
+    parser.add_argument("--intersectionWidth", type=int, default=30)
+    parser.add_argument("--numLeftLanes", type=int, default=1)
+    parser.add_argument("--numStraightLanes", type=int, default=1)
+    parser.add_argument("--numRightLanes", type=int, default=1)
+    parser.add_argument("--laneMaxSpeed", type=float, default=16.67)
+    parser.add_argument("--vehLen", type=float, default=5.0)
+    parser.add_argument("--vehWidth", type=float, default=2.0)
+    parser.add_argument("--vehMaxPosAcc", type=float, default=2.0)
+    parser.add_argument("--vehMaxNegAcc", type=float, default=4.5)
+    parser.add_argument("--vehUsualPosAcc", type=float, default=2.0)
+    parser.add_argument("--vehUsualNegAcc", type=float, default=4.5)
+    parser.add_argument("--vehMinGap", type=float, default=2.5)
+    parser.add_argument("--vehMaxSpeed", type=float, default=16.67)
+    parser.add_argument("--vehHeadwayTime", type=float, default=1.5)
+    parser.add_argument("--dir", type=str, default="./")
+    parser.add_argument("--roadnetFile", type=str)
+    parser.add_argument("--turn", action="store_true")
+    parser.add_argument("--tlPlan", action="store_true")
+    parser.add_argument("--interval", type=float, default=2.0)
+    parser.add_argument("--flowFile", type=str)
+    return parser.parse_args()
+
+def generate_route(rowNum, colNum, turn=False):
+    routes = []
+    move = [(1, 0), (0, 1), (-1, 0), (0, -1)]
+
+    def get_straight_route(start, direction, step):
+        x, y = start
+        route = []
+        for _ in range(step):
+            route.append("road_%d_%d_%d" % (x, y, direction))
+            x += move[direction][0]
+            y += move[direction][1]
+        return route
+
+    for i in range(1, rowNum+1):
+        routes.append(get_straight_route((0, i), 0, colNum+1))
+        routes.append(get_straight_route((colNum+1, i), 2, colNum+1))
+    for i in range(1, colNum+1):
+        routes.append(get_straight_route((i, 0), 1, rowNum+1))
+        routes.append(get_straight_route((i, rowNum+1), 3, rowNum+1))
+    
+    if turn:
+        def get_turn_route(start, direction):
+            if direction[0] % 2 == 0:
+                step = min(rowNum*2, colNum*2+1)
+            else:
+                step = min(colNum*2, rowNum*2+1)
+            x, y = start
+            route = []
+            cur = 0
+            for _ in range(step):
+                route.append("road_%d_%d_%d" % (x, y, direction[cur]))
+                x += move[direction[cur]][0]
+                y += move[direction[cur]][1]
+                cur = 1 - cur
+            return route
+
+        routes.append(get_turn_route((1, 0), (1, 0)))
+        routes.append(get_turn_route((0, 1), (0, 1)))
+        routes.append(get_turn_route((colNum+1, rowNum), (2, 3)))
+        routes.append(get_turn_route((colNum, rowNum+1), (3, 2)))
+        routes.append(get_turn_route((0, rowNum), (0, 3)))
+        routes.append(get_turn_route((1, rowNum+1), (3, 0)))
+        routes.append(get_turn_route((colNum+1, 1), (2, 1)))
+        routes.append(get_turn_route((colNum, 0), (1, 2)))
+    
+    return routes
+
+if __name__ == '__main__':
+    args = parse_args()
+    if args.roadnetFile is None:
+        args.roadnetFile = "roadnet_%d_%d%s.json" % (args.rowNum, args.colNum, "_turn" if args.turn else "")
+    if args.flowFile is None:
+        args.flowFile = "flow_%d_%d%s.json" % (args.rowNum, args.colNum, "_turn" if args.turn else "")
+
+    grid = {
+        "rowNumber": args.rowNum,
+        "columnNumber": args.colNum,
+        "rowDistances": [args.rowDistance] * (args.colNum-1),
+        "columnDistances": [args.columnDistance] * (args.rowNum-1),
+        "outRowDistance": args.rowDistance,
+        "outColumnDistance": args.columnDistance,
+        "intersectionWidths": [[args.intersectionWidth] * args.colNum] * args.rowNum,
+        "numLeftLanes": args.numLeftLanes,
+        "numStraightLanes": args.numStraightLanes,
+        "numRightLanes": args.numRightLanes,
+        "laneMaxSpeed": args.laneMaxSpeed,
+        "tlPlan": args.tlPlan
+    }
+
+    json.dump(gridToRoadnet(**grid), open(os.path.join(args.dir, args.roadnetFile), "w"), indent=2)
+    
+    vehicle_template = {
+        "length": args.vehLen,
+        "width": args.vehWidth,
+        "maxPosAcc": args.vehMaxPosAcc,
+        "maxNegAcc": args.vehMaxNegAcc,
+        "usualPosAcc": args.vehUsualPosAcc,
+        "usualNegAcc": args.vehUsualNegAcc,
+        "minGap": args.vehMinGap,
+        "maxSpeed": args.vehMaxSpeed,
+        "headwayTime": args.vehHeadwayTime
+    }
+    routes = generate_route(args.rowNum, args.colNum, args.turn)
+    flow = []
+    for route in routes:
+        flow.append({
+            "vehicle": vehicle_template,
+            "route": route,
+            "interval": args.interval,
+            "startTime": 0,
+            "endTime": -1
+        })
+    json.dump(flow, open(os.path.join(args.dir, args.flowFile), "w"), indent=2)
+

third_party/CityFlow/tools/generator/generate_json_from_grid.py

@@ -1,428 +1,428 @@
-from __future__ import division, print_function
-import sys
-import argparse
-import json
-import math
-import numpy as np
-
-parser = argparse.ArgumentParser(description='Generate roadnet JSON from a grid\
-            network JSON file.')
-parser.add_argument('--config', dest='config', help='grid config file', type=str)
-
-dx = [1, 0, -1, 0]
-dy = [0, 1, 0, -1]
-
-def isHorizontal(road):
-    return dx[road["direction"]] != 0
-
-def isVertical(k):
-    return dy[k] == 0
-
-def pointToDict(x, y):
-    return {"x": x, "y": y}
-
-def pointToDict2(p):
-    return {"x": float(p.x), "y": float(p.y)}
-
-def pointToDict3(p):
-    return {"x": p[0], "y": p[1]}
-
-def getLaneShift(road, laneIndex):
-    shift = 0.
-    for i in range(laneIndex):
-        shift += road["lanes"][i]["width"]
-    shift += road["lanes"][laneIndex]["width"] * .5
-    return shift
-
-def getRoadUnitVector(road):
-    startPoint = road["points"][0]
-    endPoint = road["points"][-1]
-    dx = endPoint["x"] - startPoint["x"]
-    dy = endPoint["y"] - startPoint["y"]
-    length = math.sqrt(dx * dx + dy * dy)
-    # print(length, dx, dy)
-    return dx / length, dy / length
-
-def getOutPoint(road, width, laneIndex):
-    dx, dy = getRoadUnitVector(road)
-    laneShift = getLaneShift(road, laneIndex)
-    point = road["points"][-1]
-    x, y = point["x"], point["y"]
-    x, y = x - dx * width, y - dy * width
-    x, y = x + dy * laneShift, y - dx * laneShift
-    return x, y
-
-def getOutTurnPoints(road, lim, laneIndex, width):
-    dx, dy = getRoadUnitVector(road)
-    laneShift = getLaneShift(road, laneIndex)
-    # distance = width * .5
-    point = road["points"][-1]
-    x, y = point["x"], point["y"]
-    x, y = x - dx * width, y - dy * width
-    x, y = x + dy * laneShift, y - dx * laneShift
-    return [pointToDict(x, y),
-            pointToDict(x + dx * lim, y + dy * lim)]
-
-def getInPoint(road, width, laneIndex):
-    dx, dy = getRoadUnitVector(road)
-    laneShift = getLaneShift(road, laneIndex)
-    point = road["points"][0]
-    x, y = point["x"], point["y"]
-    x, y = x + dx * width, y + dy * width
-    x, y = x + dy * laneShift, y - dx * laneShift
-    return x, y
-
-def getInTurnPoints(road, lim, laneIndex, width):
-    dx, dy = getRoadUnitVector(road)
-    laneShift = getLaneShift(road, laneIndex)
-    # distance = width * .5
-    point = road["points"][0]
-    x, y = point["x"], point["y"]
-    x, y = x + dx * width, y + dy * width
-    x, y = x + dy * laneShift, y - dx * laneShift
-    return [pointToDict(x - dx * lim, y - dy * lim),
-            pointToDict(x, y),]
-
-# Hermite Spline
-def findPath(roada, lanea, roadb, laneb, width, midPoint=10):
-    # def scale(k, p):
-    #     return p.scale(k, k)
-
-    dxa, dya = getRoadUnitVector(roada)
-    dxb, dyb = getRoadUnitVector(roadb)
-    pxa, pya = getOutPoint(roada, width, lanea)
-    pxb, pyb = getInPoint(roadb, width, laneb)
-
-    # pa = Point(pxa, pya)
-    # pb = Point(pxb, pyb)
-    dxa = dxa * width
-    dya = dya * width
-    dxb = dxb * width
-    dyb = dyb * width
-    # da = scale(width, Point(dxa, dya))
-    # db = scale(width, Point(dxb, dyb))
-
-    path = []
-    for i in range(midPoint + 1):
-        t = i / midPoint
-        t3 = t * t * t
-        t2 = t * t
-
-        k1 = 2 * t3 - 3 * t2 + 1
-        x1 = k1 * pxa
-        y1 = k1 * pya
-
-        k2 = t3 - 2 * t2 + t
-        x2 = k2 * dxa
-        y2 = k2 * dya
-
-        k3 = -2 * t3 + 3 * t2
-        x3 = k3 * pxb
-        y3 = k3 * pyb
-
-        k4 = t3 - t2
-        x4 = k4 * dxb
-        y4 = k4 * dyb
-
-        path.append([x1 + x2 + x3 + x4, y1 + y2 + y3 + y4])
-        # path.append((scale(2 * t3 - 3 * t2 + 1, pa) +
-        #             scale(t3 - 2 * t2 + t, da) +
-        #             scale(-2 * t3 + 3 * t2, pb) +
-        #             scale(t3 - t2, db)).evalf())
-    # path.append(pb)
-
-    # print(path)
-
-    return list(map(pointToDict3, path))
-
-def findPathSimple(roada, lanea, roadb, laneb, width):
-    dxa, dya = getRoadUnitVector(roada)
-    dxb, dyb = getRoadUnitVector(roadb)
-    pxa, pya = getOutPoint(roada, width, lanea)
-    pxb, pyb = getInPoint(roadb, width, laneb)
-
-    return [pointToDict(pxa, pya), pointToDict(pxa + dxa * width / 2, pya + dya * width / 2),
-            pointToDict(pxb - dxb * width / 2, pyb - dyb * width / 2), pointToDict(pxb, pyb)]
-
-def decideType(roada, roadb):
-    da = roada["direction"]
-    db = roadb["direction"]
-    if (da + 1) % 4 == db:
-        return "turn_left"
-    elif (db + 1) % 4 == da:
-        return "turn_right"
-    elif da == db:
-        return "go_straight"
-    else:
-        raise ValueError
-
-def checkIntersection(interseciontName, isTruelyInside):
-    return interseciontName
-    # _, i, j = interseciontName.split('_')
-    # i, j = int(i), int(j)
-    # if isTruelyInside(i, j):
-    #     return interseciontName
-    # else:
-    #     return None
-
-def gridToRoadnet(rowNumber, columnNumber, rowDistances, columnDistances, outRowDistance, outColumnDistance,
-                  intersectionWidths, laneWidth=4, laneMaxSpeed=20,
-                  numLeftLanes=1, numStraightLanes=1, numRightLanes=1, tlPlan=False, midPoints=10):
-
-    rowNumber += 2
-    columnNumber += 2
-    numLanes = numLeftLanes + numStraightLanes + numRightLanes
-    intersectionWidths = [[0] * columnNumber] + intersectionWidths + [[0] * columnNumber]
-    for i in range(1, rowNumber - 1):
-        intersectionWidths[i] = [0] + intersectionWidths[i] + [0]
-
-    def isInside(i, j):
-        return i >= 0 and j >= 0 and i < rowNumber and j < columnNumber
-
-    def isTruelyInside(i, j):
-        return i > 0 and j > 0 and i < rowNumber - 1 and j < columnNumber - 1
-
-    def isCorner(i, j):
-        return (i == 0 or i == rowNumber - 1) and (j == 0 or j == columnNumber - 1)
-
-    def isEdge(i, j):
-        return isInside(i, j) and not isTruelyInside(i, j)
-
-    def shouldDraw(road):
-        return isTruelyInside(road["fromi"], road["fromj"]) or isTruelyInside(road["toi"], road["toj"])
-
-    def isLeftLane(index):
-        return 0 <= index < numLeftLanes
-
-    def isStraightLane(index):
-        return numLeftLanes <= index < numLeftLanes + numStraightLanes
-
-    def isRightLane(index):
-        return numLeftLanes + numStraightLanes <= index < numLanes
-
-    x = [[None for _ in range(columnNumber)] for _ in range(rowNumber)]
-    y = [[None for _ in range(columnNumber)] for _ in range(rowNumber)]
-
-    rowDistances = [outRowDistance] + rowDistances + [outRowDistance]
-    columnDistances = [outColumnDistance] + columnDistances + [outColumnDistance]
-
-    for i in range(rowNumber):
-        for j in range(columnNumber):
-            if j > 0:
-                x[i][j] = x[i][j - 1] + rowDistances[i - 1]
-                y[i][j] = y[i][j - 1]
-            elif i > 0:
-                x[i][j] = x[i - 1][j]
-                y[i][j] = y[i - 1][j] + columnDistances[j - 1]
-            else:
-                x[i][j] = -outRowDistance
-                y[i][j] = -outColumnDistance
-
-    roads = [[[None, None, None, None] for _ in range(columnNumber)] for _ in range(rowNumber)]
-    for i in range(rowNumber):
-        for j in range(columnNumber):
-            for k in range(4):
-                ni, nj = i + dy[k], j + dx[k]
-                if not isInside(ni, nj):
-                    road = None
-                else:
-                    road = {
-                        "id": "road_%d_%d_%d" % (j, i, k),
-                        "direction": k,
-                        "fromi": i,
-                        "fromj": j,
-                        "toi": ni,
-                        "toj": nj,
-                        "points": [
-                            pointToDict(x[i][j], y[i][j]),
-                            pointToDict(x[ni][nj], y[ni][nj])
-                        ],
-                        "lanes": [
-                            {
-                                "width": laneWidth,
-                                "maxSpeed": laneMaxSpeed
-                            }
-                        ] * numLanes,
-                        "startIntersection": "intersection_%d_%d" % (j, i),
-                        "endIntersection": "intersection_%d_%d" % (nj, ni)
-                    }
-                roads[i][j][k] = road
-
-    intersections = [[None for _ in range(columnNumber)] for _ in range(rowNumber)]
-    for i in range(rowNumber):
-        for j in range(columnNumber):
-            width = intersectionWidths[i][j]
-            intersection = {
-                "id": "intersection_%d_%d" % (j, i),
-                "point": pointToDict(x[i][j], y[i][j]),
-                "width": width,
-                "roads": [],
-                "roadLinks": [],
-                "trafficLight": {
-                    "roadLinkIndices": [],
-                    "lightphases": []
-                },
-                "virtual": not isTruelyInside(i, j)
-            }
-            
-            roadLinks = intersection["roadLinks"]
-            roadLinkIndices = intersection["trafficLight"]["roadLinkIndices"]
-
-            outRoads = list(filter(lambda x: x is not None, roads[i][j]))
-            inRoads = list(map(lambda k: roads[i - dy[k]][j - dx[k]][k],
-                    filter(lambda k: isInside(i - dy[k], j - dx[k]), range(4))))
-            outRoads = list(filter(shouldDraw, outRoads))
-            inRoads = list(filter(shouldDraw, inRoads))
-
-            for road in inRoads + outRoads:
-                intersection["roads"].append(road["id"])
-
-            for a in range(len(inRoads)):
-                for b in range(len(outRoads)):
-                    try:
-                        roada = inRoads[a]
-                        roadb = outRoads[b]
-                        roadLink = {
-                            "type": decideType(roada, roadb),
-                            "startRoad": roada["id"],
-                            "endRoad": roadb["id"],
-                            "direction": roada["direction"],
-                            "laneLinks": []
-                        }
-                        for c in range(len(roada["lanes"])):
-                            if roadLink["type"] == "turn_left" and not isLeftLane(c):
-                                continue
-                            if roadLink["type"] == "go_straight" and not isStraightLane(c):
-                                continue
-                            if roadLink["type"] == "turn_right" and not isRightLane(c):
-                                continue
-                            for d in range(len(roadb["lanes"])):
-                                path = {
-                                    "startLaneIndex": c,
-                                    "endLaneIndex": d,
-                                    "points": findPath(roada, c, roadb, d, width, midPoints)
-                                }
-                                roadLink["laneLinks"].append(path)
-                        if roadLink["laneLinks"]:
-                            roadLinkIndices.append(len(roadLinks))
-                            roadLinks.append(roadLink)
-                    except ValueError:
-                        pass
-            
-            leftLaneLinks = set(filter(lambda x: roadLinks[x]["type"] == "turn_left", roadLinkIndices))
-            rightLaneLinks = set(filter(lambda x: roadLinks[x]["type"] == "turn_right", roadLinkIndices))
-            straightLaneLinks = set(filter(lambda x: roadLinks[x]["type"] == "go_straight", roadLinkIndices))
-            WELaneLinks = set(filter(lambda x: roadLinks[x]["direction"] == 0, roadLinkIndices))
-            NSLaneLinks = set(filter(lambda x: roadLinks[x]["direction"] == 1, roadLinkIndices))
-            EWLaneLinks = set(filter(lambda x: roadLinks[x]["direction"] == 2, roadLinkIndices))
-            SNLaneLinks = set(filter(lambda x: roadLinks[x]["direction"] == 3, roadLinkIndices))
-            
-            tlPhases = intersection["trafficLight"]["lightphases"]
-            if not tlPlan:
-                tlPhases.append({
-                    "time": 5,
-                    "availableRoadLinks": rightLaneLinks
-                })
-                tlPhases.append({
-                    "time": 30,
-                    "availableRoadLinks": ((EWLaneLinks | WELaneLinks) & straightLaneLinks) | (rightLaneLinks)
-                })
-                tlPhases.append({
-                    "time": 30,
-                    "availableRoadLinks": ((NSLaneLinks | SNLaneLinks) & straightLaneLinks) | (rightLaneLinks)
-                })
-                tlPhases.append({
-                    "time": 30,
-                    "availableRoadLinks": ((EWLaneLinks | WELaneLinks) & leftLaneLinks) | (rightLaneLinks)
-                })
-                tlPhases.append({
-                    "time": 30,
-                    "availableRoadLinks": ((SNLaneLinks | NSLaneLinks) & leftLaneLinks) | (rightLaneLinks)
-                })
-                tlPhases.append({
-                    "time": 30,
-                    "availableRoadLinks": (WELaneLinks) | (rightLaneLinks)
-                })
-                tlPhases.append({
-                    "time": 30,
-                    "availableRoadLinks": (EWLaneLinks) | (rightLaneLinks)
-                })
-                tlPhases.append({
-                    "time": 30,
-                    "availableRoadLinks": (NSLaneLinks) | (rightLaneLinks)
-                })
-                tlPhases.append({
-                    "time": 30,
-                    "availableRoadLinks": (SNLaneLinks) | (rightLaneLinks)
-                })
-            else:
-                tlPhases.append({
-                    "time": 30,
-                    "availableRoadLinks": ((EWLaneLinks | WELaneLinks) & straightLaneLinks) | (rightLaneLinks)
-                })
-                tlPhases.append({
-                    "time": 5,
-                    "availableRoadLinks": rightLaneLinks
-                })
-                if numLeftLanes:
-                    tlPhases.append({
-                        "time": 30,
-                        "availableRoadLinks": ((EWLaneLinks | WELaneLinks) & leftLaneLinks) | (rightLaneLinks)
-                    })
-                    tlPhases.append({
-                        "time": 5,
-                        "availableRoadLinks": rightLaneLinks
-                    })
-                tlPhases.append({
-                    "time": 30,
-                    "availableRoadLinks": ((NSLaneLinks | SNLaneLinks) & straightLaneLinks) | (rightLaneLinks)
-                })
-                tlPhases.append({
-                    "time": 5,
-                    "availableRoadLinks": rightLaneLinks
-                })
-                if numLeftLanes:
-                    tlPhases.append({
-                        "time": 30,
-                        "availableRoadLinks": ((SNLaneLinks | NSLaneLinks) & leftLaneLinks) | (rightLaneLinks)
-                    })
-                    tlPhases.append({
-                        "time": 5,
-                        "availableRoadLinks": rightLaneLinks
-                    })
-            for tlPhase in tlPhases:
-                tlPhase["availableRoadLinks"] = list(tlPhase["availableRoadLinks"])
-            intersections[i][j] = intersection
-
-    final_intersecions = []
-    for i in range(rowNumber):
-        for j in range(columnNumber):
-            if not isCorner(i, j):
-                # print(i, j)
-                final_intersecions.append(intersections[i][j])
-
-    final_roads = []
-    for i in range(rowNumber):
-        for j in range(columnNumber):
-            for k in range(4):
-                if roads[i][j][k] is not None and shouldDraw(roads[i][j][k]):
-                    ni, nj = i + dy[k], j + dx[k]
-                    roads[i][j][k].pop("direction")
-                    roads[i][j][k].pop("fromi")
-                    roads[i][j][k].pop("fromj")
-                    roads[i][j][k].pop("toi")
-                    roads[i][j][k].pop("toj")
-                    roads[i][j][k]["startIntersection"] = checkIntersection(roads[i][j][k]["startIntersection"], isTruelyInside)
-                    roads[i][j][k]["endIntersection"] = checkIntersection(roads[i][j][k]["endIntersection"], isTruelyInside)
-                    final_roads.append(roads[i][j][k])
-
-    return {
-        "intersections": final_intersecions,
-        "roads": final_roads
-    }
-
-if __name__ == "__main__":
-    args = parser.parse_args()
-    path = '../data/roadnet/'
-    grid_config = json.load(open(path + args.config if args.config is not None else path + 'grid66.json'))
-    json.dump(gridToRoadnet(**grid_config), open(path + "roadnet66.json", "w"), indent=2)
+from __future__ import division, print_function
+import sys
+import argparse
+import json
+import math
+import numpy as np
+
+parser = argparse.ArgumentParser(description='Generate roadnet JSON from a grid\
+            network JSON file.')
+parser.add_argument('--config', dest='config', help='grid config file', type=str)
+
+dx = [1, 0, -1, 0]
+dy = [0, 1, 0, -1]
+
+def isHorizontal(road):
+    return dx[road["direction"]] != 0
+
+def isVertical(k):
+    return dy[k] == 0
+
+def pointToDict(x, y):
+    return {"x": x, "y": y}
+
+def pointToDict2(p):
+    return {"x": float(p.x), "y": float(p.y)}
+
+def pointToDict3(p):
+    return {"x": p[0], "y": p[1]}
+
+def getLaneShift(road, laneIndex):
+    shift = 0.
+    for i in range(laneIndex):
+        shift += road["lanes"][i]["width"]
+    shift += road["lanes"][laneIndex]["width"] * .5
+    return shift
+
+def getRoadUnitVector(road):
+    startPoint = road["points"][0]
+    endPoint = road["points"][-1]
+    dx = endPoint["x"] - startPoint["x"]
+    dy = endPoint["y"] - startPoint["y"]
+    length = math.sqrt(dx * dx + dy * dy)
+    # print(length, dx, dy)
+    return dx / length, dy / length
+
+def getOutPoint(road, width, laneIndex):
+    dx, dy = getRoadUnitVector(road)
+    laneShift = getLaneShift(road, laneIndex)
+    point = road["points"][-1]
+    x, y = point["x"], point["y"]
+    x, y = x - dx * width, y - dy * width
+    x, y = x + dy * laneShift, y - dx * laneShift
+    return x, y
+
+def getOutTurnPoints(road, lim, laneIndex, width):
+    dx, dy = getRoadUnitVector(road)
+    laneShift = getLaneShift(road, laneIndex)
+    # distance = width * .5
+    point = road["points"][-1]
+    x, y = point["x"], point["y"]
+    x, y = x - dx * width, y - dy * width
+    x, y = x + dy * laneShift, y - dx * laneShift
+    return [pointToDict(x, y),
+            pointToDict(x + dx * lim, y + dy * lim)]
+
+def getInPoint(road, width, laneIndex):
+    dx, dy = getRoadUnitVector(road)
+    laneShift = getLaneShift(road, laneIndex)
+    point = road["points"][0]
+    x, y = point["x"], point["y"]
+    x, y = x + dx * width, y + dy * width
+    x, y = x + dy * laneShift, y - dx * laneShift
+    return x, y
+
+def getInTurnPoints(road, lim, laneIndex, width):
+    dx, dy = getRoadUnitVector(road)
+    laneShift = getLaneShift(road, laneIndex)
+    # distance = width * .5
+    point = road["points"][0]
+    x, y = point["x"], point["y"]
+    x, y = x + dx * width, y + dy * width
+    x, y = x + dy * laneShift, y - dx * laneShift
+    return [pointToDict(x - dx * lim, y - dy * lim),
+            pointToDict(x, y),]
+
+# Hermite Spline
+def findPath(roada, lanea, roadb, laneb, width, midPoint=10):
+    # def scale(k, p):
+    #     return p.scale(k, k)
+
+    dxa, dya = getRoadUnitVector(roada)
+    dxb, dyb = getRoadUnitVector(roadb)
+    pxa, pya = getOutPoint(roada, width, lanea)
+    pxb, pyb = getInPoint(roadb, width, laneb)
+
+    # pa = Point(pxa, pya)
+    # pb = Point(pxb, pyb)
+    dxa = dxa * width
+    dya = dya * width
+    dxb = dxb * width
+    dyb = dyb * width
+    # da = scale(width, Point(dxa, dya))
+    # db = scale(width, Point(dxb, dyb))
+
+    path = []
+    for i in range(midPoint + 1):
+        t = i / midPoint
+        t3 = t * t * t
+        t2 = t * t
+
+        k1 = 2 * t3 - 3 * t2 + 1
+        x1 = k1 * pxa
+        y1 = k1 * pya
+
+        k2 = t3 - 2 * t2 + t
+        x2 = k2 * dxa
+        y2 = k2 * dya
+
+        k3 = -2 * t3 + 3 * t2
+        x3 = k3 * pxb
+        y3 = k3 * pyb
+
+        k4 = t3 - t2
+        x4 = k4 * dxb
+        y4 = k4 * dyb
+
+        path.append([x1 + x2 + x3 + x4, y1 + y2 + y3 + y4])
+        # path.append((scale(2 * t3 - 3 * t2 + 1, pa) +
+        #             scale(t3 - 2 * t2 + t, da) +
+        #             scale(-2 * t3 + 3 * t2, pb) +
+        #             scale(t3 - t2, db)).evalf())
+    # path.append(pb)
+
+    # print(path)
+
+    return list(map(pointToDict3, path))
+
+def findPathSimple(roada, lanea, roadb, laneb, width):
+    dxa, dya = getRoadUnitVector(roada)
+    dxb, dyb = getRoadUnitVector(roadb)
+    pxa, pya = getOutPoint(roada, width, lanea)
+    pxb, pyb = getInPoint(roadb, width, laneb)
+
+    return [pointToDict(pxa, pya), pointToDict(pxa + dxa * width / 2, pya + dya * width / 2),
+            pointToDict(pxb - dxb * width / 2, pyb - dyb * width / 2), pointToDict(pxb, pyb)]
+
+def decideType(roada, roadb):
+    da = roada["direction"]
+    db = roadb["direction"]
+    if (da + 1) % 4 == db:
+        return "turn_left"
+    elif (db + 1) % 4 == da:
+        return "turn_right"
+    elif da == db:
+        return "go_straight"
+    else:
+        raise ValueError
+
+def checkIntersection(interseciontName, isTruelyInside):
+    return interseciontName
+    # _, i, j = interseciontName.split('_')
+    # i, j = int(i), int(j)
+    # if isTruelyInside(i, j):
+    #     return interseciontName
+    # else:
+    #     return None
+
+def gridToRoadnet(rowNumber, columnNumber, rowDistances, columnDistances, outRowDistance, outColumnDistance,
+                  intersectionWidths, laneWidth=4, laneMaxSpeed=20,
+                  numLeftLanes=1, numStraightLanes=1, numRightLanes=1, tlPlan=False, midPoints=10):
+
+    rowNumber += 2
+    columnNumber += 2
+    numLanes = numLeftLanes + numStraightLanes + numRightLanes
+    intersectionWidths = [[0] * columnNumber] + intersectionWidths + [[0] * columnNumber]
+    for i in range(1, rowNumber - 1):
+        intersectionWidths[i] = [0] + intersectionWidths[i] + [0]
+
+    def isInside(i, j):
+        return i >= 0 and j >= 0 and i < rowNumber and j < columnNumber
+
+    def isTruelyInside(i, j):
+        return i > 0 and j > 0 and i < rowNumber - 1 and j < columnNumber - 1
+
+    def isCorner(i, j):
+        return (i == 0 or i == rowNumber - 1) and (j == 0 or j == columnNumber - 1)
+
+    def isEdge(i, j):
+        return isInside(i, j) and not isTruelyInside(i, j)
+
+    def shouldDraw(road):
+        return isTruelyInside(road["fromi"], road["fromj"]) or isTruelyInside(road["toi"], road["toj"])
+
+    def isLeftLane(index):
+        return 0 <= index < numLeftLanes
+
+    def isStraightLane(index):
+        return numLeftLanes <= index < numLeftLanes + numStraightLanes
+
+    def isRightLane(index):
+        return numLeftLanes + numStraightLanes <= index < numLanes
+
+    x = [[None for _ in range(columnNumber)] for _ in range(rowNumber)]
+    y = [[None for _ in range(columnNumber)] for _ in range(rowNumber)]
+
+    rowDistances = [outRowDistance] + rowDistances + [outRowDistance]
+    columnDistances = [outColumnDistance] + columnDistances + [outColumnDistance]
+
+    for i in range(rowNumber):
+        for j in range(columnNumber):
+            if j > 0:
+                x[i][j] = x[i][j - 1] + rowDistances[i - 1]
+                y[i][j] = y[i][j - 1]
+            elif i > 0:
+                x[i][j] = x[i - 1][j]
+                y[i][j] = y[i - 1][j] + columnDistances[j - 1]
+            else:
+                x[i][j] = -outRowDistance
+                y[i][j] = -outColumnDistance
+
+    roads = [[[None, None, None, None] for _ in range(columnNumber)] for _ in range(rowNumber)]
+    for i in range(rowNumber):
+        for j in range(columnNumber):
+            for k in range(4):
+                ni, nj = i + dy[k], j + dx[k]
+                if not isInside(ni, nj):
+                    road = None
+                else:
+                    road = {
+                        "id": "road_%d_%d_%d" % (j, i, k),
+                        "direction": k,
+                        "fromi": i,
+                        "fromj": j,
+                        "toi": ni,
+                        "toj": nj,
+                        "points": [
+                            pointToDict(x[i][j], y[i][j]),
+                            pointToDict(x[ni][nj], y[ni][nj])
+                        ],
+                        "lanes": [
+                            {
+                                "width": laneWidth,
+                                "maxSpeed": laneMaxSpeed
+                            }
+                        ] * numLanes,
+                        "startIntersection": "intersection_%d_%d" % (j, i),
+                        "endIntersection": "intersection_%d_%d" % (nj, ni)
+                    }
+                roads[i][j][k] = road
+
+    intersections = [[None for _ in range(columnNumber)] for _ in range(rowNumber)]
+    for i in range(rowNumber):
+        for j in range(columnNumber):
+            width = intersectionWidths[i][j]
+            intersection = {
+                "id": "intersection_%d_%d" % (j, i),
+                "point": pointToDict(x[i][j], y[i][j]),
+                "width": width,
+                "roads": [],
+                "roadLinks": [],
+                "trafficLight": {
+                    "roadLinkIndices": [],
+                    "lightphases": []
+                },
+                "virtual": not isTruelyInside(i, j)
+            }
+            
+            roadLinks = intersection["roadLinks"]
+            roadLinkIndices = intersection["trafficLight"]["roadLinkIndices"]
+
+            outRoads = list(filter(lambda x: x is not None, roads[i][j]))
+            inRoads = list(map(lambda k: roads[i - dy[k]][j - dx[k]][k],
+                    filter(lambda k: isInside(i - dy[k], j - dx[k]), range(4))))
+            outRoads = list(filter(shouldDraw, outRoads))
+            inRoads = list(filter(shouldDraw, inRoads))
+
+            for road in inRoads + outRoads:
+                intersection["roads"].append(road["id"])
+
+            for a in range(len(inRoads)):
+                for b in range(len(outRoads)):
+                    try:
+                        roada = inRoads[a]
+                        roadb = outRoads[b]
+                        roadLink = {
+                            "type": decideType(roada, roadb),
+                            "startRoad": roada["id"],
+                            "endRoad": roadb["id"],
+                            "direction": roada["direction"],
+                            "laneLinks": []
+                        }
+                        for c in range(len(roada["lanes"])):
+                            if roadLink["type"] == "turn_left" and not isLeftLane(c):
+                                continue
+                            if roadLink["type"] == "go_straight" and not isStraightLane(c):
+                                continue
+                            if roadLink["type"] == "turn_right" and not isRightLane(c):
+                                continue
+                            for d in range(len(roadb["lanes"])):
+                                path = {
+                                    "startLaneIndex": c,
+                                    "endLaneIndex": d,
+                                    "points": findPath(roada, c, roadb, d, width, midPoints)
+                                }
+                                roadLink["laneLinks"].append(path)
+                        if roadLink["laneLinks"]:
+                            roadLinkIndices.append(len(roadLinks))
+                            roadLinks.append(roadLink)
+                    except ValueError:
+                        pass
+            
+            leftLaneLinks = set(filter(lambda x: roadLinks[x]["type"] == "turn_left", roadLinkIndices))
+            rightLaneLinks = set(filter(lambda x: roadLinks[x]["type"] == "turn_right", roadLinkIndices))
+            straightLaneLinks = set(filter(lambda x: roadLinks[x]["type"] == "go_straight", roadLinkIndices))
+            WELaneLinks = set(filter(lambda x: roadLinks[x]["direction"] == 0, roadLinkIndices))
+            NSLaneLinks = set(filter(lambda x: roadLinks[x]["direction"] == 1, roadLinkIndices))
+            EWLaneLinks = set(filter(lambda x: roadLinks[x]["direction"] == 2, roadLinkIndices))
+            SNLaneLinks = set(filter(lambda x: roadLinks[x]["direction"] == 3, roadLinkIndices))
+            
+            tlPhases = intersection["trafficLight"]["lightphases"]
+            if not tlPlan:
+                tlPhases.append({
+                    "time": 5,
+                    "availableRoadLinks": rightLaneLinks
+                })
+                tlPhases.append({
+                    "time": 30,
+                    "availableRoadLinks": ((EWLaneLinks | WELaneLinks) & straightLaneLinks) | (rightLaneLinks)
+                })
+                tlPhases.append({
+                    "time": 30,
+                    "availableRoadLinks": ((NSLaneLinks | SNLaneLinks) & straightLaneLinks) | (rightLaneLinks)
+                })
+                tlPhases.append({
+                    "time": 30,
+                    "availableRoadLinks": ((EWLaneLinks | WELaneLinks) & leftLaneLinks) | (rightLaneLinks)
+                })
+                tlPhases.append({
+                    "time": 30,
+                    "availableRoadLinks": ((SNLaneLinks | NSLaneLinks) & leftLaneLinks) | (rightLaneLinks)
+                })
+                tlPhases.append({
+                    "time": 30,
+                    "availableRoadLinks": (WELaneLinks) | (rightLaneLinks)
+                })
+                tlPhases.append({
+                    "time": 30,
+                    "availableRoadLinks": (EWLaneLinks) | (rightLaneLinks)
+                })
+                tlPhases.append({
+                    "time": 30,
+                    "availableRoadLinks": (NSLaneLinks) | (rightLaneLinks)
+                })
+                tlPhases.append({
+                    "time": 30,
+                    "availableRoadLinks": (SNLaneLinks) | (rightLaneLinks)
+                })
+            else:
+                tlPhases.append({
+                    "time": 30,
+                    "availableRoadLinks": ((EWLaneLinks | WELaneLinks) & straightLaneLinks) | (rightLaneLinks)
+                })
+                tlPhases.append({
+                    "time": 5,
+                    "availableRoadLinks": rightLaneLinks
+                })
+                if numLeftLanes:
+                    tlPhases.append({
+                        "time": 30,
+                        "availableRoadLinks": ((EWLaneLinks | WELaneLinks) & leftLaneLinks) | (rightLaneLinks)
+                    })
+                    tlPhases.append({
+                        "time": 5,
+                        "availableRoadLinks": rightLaneLinks
+                    })
+                tlPhases.append({
+                    "time": 30,
+                    "availableRoadLinks": ((NSLaneLinks | SNLaneLinks) & straightLaneLinks) | (rightLaneLinks)
+                })
+                tlPhases.append({
+                    "time": 5,
+                    "availableRoadLinks": rightLaneLinks
+                })
+                if numLeftLanes:
+                    tlPhases.append({
+                        "time": 30,
+                        "availableRoadLinks": ((SNLaneLinks | NSLaneLinks) & leftLaneLinks) | (rightLaneLinks)
+                    })
+                    tlPhases.append({
+                        "time": 5,
+                        "availableRoadLinks": rightLaneLinks
+                    })
+            for tlPhase in tlPhases:
+                tlPhase["availableRoadLinks"] = list(tlPhase["availableRoadLinks"])
+            intersections[i][j] = intersection
+
+    final_intersecions = []
+    for i in range(rowNumber):
+        for j in range(columnNumber):
+            if not isCorner(i, j):
+                # print(i, j)
+                final_intersecions.append(intersections[i][j])
+
+    final_roads = []
+    for i in range(rowNumber):
+        for j in range(columnNumber):
+            for k in range(4):
+                if roads[i][j][k] is not None and shouldDraw(roads[i][j][k]):
+                    ni, nj = i + dy[k], j + dx[k]
+                    roads[i][j][k].pop("direction")
+                    roads[i][j][k].pop("fromi")
+                    roads[i][j][k].pop("fromj")
+                    roads[i][j][k].pop("toi")
+                    roads[i][j][k].pop("toj")
+                    roads[i][j][k]["startIntersection"] = checkIntersection(roads[i][j][k]["startIntersection"], isTruelyInside)
+                    roads[i][j][k]["endIntersection"] = checkIntersection(roads[i][j][k]["endIntersection"], isTruelyInside)
+                    final_roads.append(roads[i][j][k])
+
+    return {
+        "intersections": final_intersecions,
+        "roads": final_roads
+    }
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+    path = '../data/roadnet/'
+    grid_config = json.load(open(path + args.config if args.config is not None else path + 'grid66.json'))
+    json.dump(gridToRoadnet(**grid_config), open(path + "roadnet66.json", "w"), indent=2)

third_party/CityFlow/tools/generator/readme.md

@@ -1,41 +1,41 @@
-# Generator
-
-`generate_grid_scenario.py` can generate NxM grid road network with traffic flows. 
-
-### Quick Start
-
-To generate a 3x4 grid road network
-
-```
-python generate_grid_scenario.py 3 4 
-```
-
-To generate a 3x4 grid road network with 2 straight lanes and with a predefined working traffic light plan
-
-```
-python generate_grid_scenario.py 3 4 --numStraightLanes 2 --tlPlan
-```
-
-### Other arguments
-- `--rowDistance`: int, default=300, distance between consecutive intersections of each row (East-West Roads
-- `--columnDistance`: int, default=300, distance between consecutive intersections of each column (South-North Roads
-- `--intersectionWidth`: int, default=30
-- `--numLeftLanes`: int, default=1
-- `--numStraightLanes`: int, default=1
-- `--numRightLanes`: int, default=1
-- `--laneMaxSpeed`: int, default=16.67, meters/second
-- `--vehLen`: float, default=5.0, meters
-- `--vehWidth`: float, default=2.0, meters
-- `--vehMaxPosAcc`: float, default=2.0
-- `--vehMaxNegAcc`: float, default=4.5
-- `--vehUsualPosAcc`: float, default=2.0
-- `--vehUsualNegAcc`: float, default=4.5
-- `--vehMinGap`: float, default=2.5
-- `--vehMaxSpeed`: float, default=16.67
-- `--vehHeadwayTime`: float, default=1.5
-- `--dir`: str, default="./"
-- `--roadnetFile`: str, generated road network file
-- `--turn`: if specified, generate turning flows instead of straight flows
-- `--tlPlan`: if specified, generate working predefined traffic signal plan instead of plans with default orders
-- `--interval`: float, default=2.0, time (seconds) between each vehicle for each flow
-- `--flowFile`: str, generated flow file
+# Generator
+
+`generate_grid_scenario.py` can generate NxM grid road network with traffic flows. 
+
+### Quick Start
+
+To generate a 3x4 grid road network
+
+```
+python generate_grid_scenario.py 3 4 
+```
+
+To generate a 3x4 grid road network with 2 straight lanes and with a predefined working traffic light plan
+
+```
+python generate_grid_scenario.py 3 4 --numStraightLanes 2 --tlPlan
+```
+
+### Other arguments
+- `--rowDistance`: int, default=300, distance between consecutive intersections of each row (East-West Roads
+- `--columnDistance`: int, default=300, distance between consecutive intersections of each column (South-North Roads
+- `--intersectionWidth`: int, default=30
+- `--numLeftLanes`: int, default=1
+- `--numStraightLanes`: int, default=1
+- `--numRightLanes`: int, default=1
+- `--laneMaxSpeed`: int, default=16.67, meters/second
+- `--vehLen`: float, default=5.0, meters
+- `--vehWidth`: float, default=2.0, meters
+- `--vehMaxPosAcc`: float, default=2.0
+- `--vehMaxNegAcc`: float, default=4.5
+- `--vehUsualPosAcc`: float, default=2.0
+- `--vehUsualNegAcc`: float, default=4.5
+- `--vehMinGap`: float, default=2.5
+- `--vehMaxSpeed`: float, default=16.67
+- `--vehHeadwayTime`: float, default=1.5
+- `--dir`: str, default="./"
+- `--roadnetFile`: str, generated road network file
+- `--turn`: if specified, generate turning flows instead of straight flows
+- `--tlPlan`: if specified, generate working predefined traffic signal plan instead of plans with default orders
+- `--interval`: float, default=2.0, time (seconds) between each vehicle for each flow
+- `--flowFile`: str, generated flow file

training/README.md

@@ -1,38 +1,38 @@
-# training
-
-Training, evaluation, device selection, and dataset utilities for the local multi-agent DQN stack.
-
-## Main files
-
-- [train_local_policy.py](/Users/aditya/Developer/traffic-llm/training/train_local_policy.py)
-  Main CLI for split generation, DQN training, and checkpoint evaluation.
-- [trainer.py](/Users/aditya/Developer/traffic-llm/training/trainer.py)
-  Replay buffer, DQN training loop, checkpointing, validation, and aggregate metrics.
-- [rollout.py](/Users/aditya/Developer/traffic-llm/training/rollout.py)
-  Evaluation helper shared by learned agents and rule-based baselines.
-- [models.py](/Users/aditya/Developer/traffic-llm/training/models.py)
-  Dueling Q-network and running observation normalization.
-- [device.py](/Users/aditya/Developer/traffic-llm/training/device.py)
-  Torch device selection for `cuda`, `mps`, or `cpu`.
-- [cityflow_dataset.py](/root/aditya/agentic-traffic/training/cityflow_dataset.py)
-  City discovery, split loading, and scenario sampling.
-
-## Main entry points
-
-- `python3 -m training.train_local_policy make-splits`
-- `python3 -m training.train_local_policy train`
-- `python3 -m training.train_local_policy train --max-val-cities 3 --val-scenarios-per-city 7`
-- `python3 -m training.train_local_policy train --max-train-cities 70 --max-val-cities 3 --val-scenarios-per-city 7 --policy-arch single_head_with_district_feature --reward-variant wait_queue_throughput`
-- `python3 -m training.train_local_policy train --policy-arch single_head_with_district_feature --reward-variant wait_queue_throughput`
-- `python3 -m training.train_local_policy evaluate --checkpoint artifacts/dqn_shared/best_validation.pt --split val`
-- `python3 -m training.train_local_policy evaluate --baseline queue_greedy --split val`
-- `tensorboard --logdir artifacts/dqn_shared/tensorboard`
-
-## Training flow
-
-1. Load city-level splits from `data/splits/`.
-2. Sample one `(city, scenario)` episode at a time from the train split.
-3. Run one shared Q-network across all controlled intersections in that city.
-4. Collect per-intersection transitions into prioritized replay with n-step returns, using parallel CPU rollout workers by default.
-5. Perform Double DQN updates against a target network.
-6. Periodically evaluate on validation cities and save checkpoints. By default, eval and checkpoint cadence are both 40 updates, and each validation pass also writes an `update_XXXX.pt` checkpoint.
+# training
+
+Training, evaluation, device selection, and dataset utilities for the local multi-agent DQN stack.
+
+## Main files
+
+- [train_local_policy.py](/Users/aditya/Developer/traffic-llm/training/train_local_policy.py)
+  Main CLI for split generation, DQN training, and checkpoint evaluation.
+- [trainer.py](/Users/aditya/Developer/traffic-llm/training/trainer.py)
+  Replay buffer, DQN training loop, checkpointing, validation, and aggregate metrics.
+- [rollout.py](/Users/aditya/Developer/traffic-llm/training/rollout.py)
+  Evaluation helper shared by learned agents and rule-based baselines.
+- [models.py](/Users/aditya/Developer/traffic-llm/training/models.py)
+  Dueling Q-network and running observation normalization.
+- [device.py](/Users/aditya/Developer/traffic-llm/training/device.py)
+  Torch device selection for `cuda`, `mps`, or `cpu`.
+- [cityflow_dataset.py](/root/aditya/agentic-traffic/training/cityflow_dataset.py)
+  City discovery, split loading, and scenario sampling.
+
+## Main entry points
+
+- `python3 -m training.train_local_policy make-splits`
+- `python3 -m training.train_local_policy train`
+- `python3 -m training.train_local_policy train --max-val-cities 3 --val-scenarios-per-city 7`
+- `python3 -m training.train_local_policy train --max-train-cities 70 --max-val-cities 3 --val-scenarios-per-city 7 --policy-arch single_head_with_district_feature --reward-variant wait_queue_throughput`
+- `python3 -m training.train_local_policy train --policy-arch single_head_with_district_feature --reward-variant wait_queue_throughput`
+- `python3 -m training.train_local_policy evaluate --checkpoint artifacts/dqn_shared/best_validation.pt --split val`
+- `python3 -m training.train_local_policy evaluate --baseline queue_greedy --split val`
+- `tensorboard --logdir artifacts/dqn_shared/tensorboard`
+
+## Training flow
+
+1. Load city-level splits from `data/splits/`.
+2. Sample one `(city, scenario)` episode at a time from the train split.
+3. Run one shared Q-network across all controlled intersections in that city.
+4. Collect per-intersection transitions into prioritized replay with n-step returns, using parallel CPU rollout workers by default.
+5. Perform Double DQN updates against a target network.
+6. Periodically evaluate on validation cities and save checkpoints. By default, eval and checkpoint cadence are both 40 updates, and each validation pass also writes an `update_XXXX.pt` checkpoint.

training/__init__.py

@@ -1,6 +1,6 @@
-from training.cityflow_dataset import CityFlowDataset, ScenarioSpec
-
-__all__ = [
-    "CityFlowDataset",
-    "ScenarioSpec",
-]
+from training.cityflow_dataset import CityFlowDataset, ScenarioSpec
+
+__all__ = [
+    "CityFlowDataset",
+    "ScenarioSpec",
+]

training/cityflow_dataset.py

@@ -1,202 +1,202 @@
-from __future__ import annotations
-
-import random
-from dataclasses import dataclass
-from pathlib import Path
-
-
-DEFAULT_SCENARIOS = (
-    "normal",
-    "morning_rush",
-    "evening_rush",
-    "accident",
-    "construction",
-    "district_overload",
-    "event_spike",
-)
-
-
-@dataclass(frozen=True)
-class ScenarioSpec:
-    city_id: str
-    scenario_name: str
-    city_dir: Path
-    scenario_dir: Path
-    config_path: Path
-    roadnet_path: Path
-    district_map_path: Path
-    metadata_path: Path
-
-
-class CityFlowDataset:
-    def __init__(
-        self,
-        generated_root: str | Path = "data/generated",
-        splits_root: str | Path = "data/splits",
-    ):
-        self.generated_root = Path(generated_root)
-        self.splits_root = Path(splits_root)
-
-    def discover_cities(self) -> list[str]:
-        return sorted(
-            city_dir.name
-            for city_dir in self.generated_root.glob("city_*")
-            if city_dir.is_dir() and (city_dir / "roadnet.json").exists()
-        )
-
-    def scenarios_for_city(self, city_id: str) -> list[str]:
-        scenario_root = self.generated_root / city_id / "scenarios"
-        return sorted(
-            scenario_dir.name
-            for scenario_dir in scenario_root.iterdir()
-            if scenario_dir.is_dir()
-            and (scenario_dir / "config.json").exists()
-            and (scenario_dir / "flow.json").exists()
-        )
-
-    def load_split(self, split_name: str, create_if_missing: bool = True) -> list[str]:
-        split_path = self.splits_root / f"{split_name}_cities.txt"
-        if not split_path.exists():
-            if not create_if_missing:
-                raise FileNotFoundError(f"Missing split file: {split_path}")
-            self.generate_default_splits()
-
-        split_cities = [
-            line.strip()
-            for line in split_path.read_text().splitlines()
-            if line.strip()
-        ]
-        available_cities = set(self.discover_cities())
-        filtered_cities = [city_id for city_id in split_cities if city_id in available_cities]
-        if filtered_cities:
-            return filtered_cities
-
-        if create_if_missing and available_cities:
-            splits = self.generate_default_splits(overwrite=True)
-            return splits.get(split_name, [])
-
-        return filtered_cities
-
-    def generate_default_splits(
-        self,
-        seed: int = 7,
-        train_ratio: float = 0.7,
-        val_ratio: float = 0.15,
-        overwrite: bool = False,
-    ) -> dict[str, list[str]]:
-        self.splits_root.mkdir(parents=True, exist_ok=True)
-
-        train_path = self.splits_root / "train_cities.txt"
-        val_path = self.splits_root / "val_cities.txt"
-        test_path = self.splits_root / "test_cities.txt"
-        if not overwrite and train_path.exists() and val_path.exists() and test_path.exists():
-            return {
-                "train": self.load_split("train", create_if_missing=False),
-                "val": self.load_split("val", create_if_missing=False),
-                "test": self.load_split("test", create_if_missing=False),
-            }
-
-        city_ids = self.discover_cities()
-        rng = random.Random(seed)
-        rng.shuffle(city_ids)
-
-        num_cities = len(city_ids)
-        if num_cities == 0:
-            splits = {"train": [], "val": [], "test": []}
-        elif num_cities == 1:
-            splits = {"train": city_ids[:], "val": city_ids[:], "test": city_ids[:]}
-        elif num_cities == 2:
-            splits = {
-                "train": sorted(city_ids[:1]),
-                "val": sorted(city_ids[1:2]),
-                "test": sorted(city_ids[:1]),
-            }
-        else:
-            train_count = max(1, int(num_cities * train_ratio))
-            val_count = int(num_cities * val_ratio)
-            if train_count + val_count >= num_cities:
-                val_count = max(0, num_cities - train_count - 1)
-            test_count = num_cities - train_count - val_count
-            if test_count <= 0:
-                test_count = 1
-                if val_count > 0:
-                    val_count -= 1
-                else:
-                    train_count = max(1, train_count - 1)
-
-            splits = {
-                "train": sorted(city_ids[:train_count]),
-                "val": sorted(city_ids[train_count : train_count + val_count]),
-                "test": sorted(city_ids[train_count + val_count :]),
-            }
-
-        for split_name, city_list in splits.items():
-            split_path = self.splits_root / f"{split_name}_cities.txt"
-            split_path.write_text("\n".join(city_list) + "\n")
-
-        return splits
-
-    def build_scenario_spec(self, city_id: str, scenario_name: str) -> ScenarioSpec:
-        city_dir = self.generated_root / city_id
-        scenario_dir = city_dir / "scenarios" / scenario_name
-        return ScenarioSpec(
-            city_id=city_id,
-            scenario_name=scenario_name,
-            city_dir=city_dir,
-            scenario_dir=scenario_dir,
-            config_path=scenario_dir / "config.json",
-            roadnet_path=city_dir / "roadnet.json",
-            district_map_path=city_dir / "district_map.json",
-            metadata_path=city_dir / "metadata.json",
-        )
-
-    def sample_scenario(
-        self,
-        split_name: str,
-        rng: random.Random,
-        city_id: str | None = None,
-        scenario_name: str | None = None,
-    ) -> ScenarioSpec:
-        available_cities = self.load_split(split_name)
-        if not available_cities:
-            available_cities = self.discover_cities()
-        if not available_cities:
-            raise FileNotFoundError(
-                f"No generated cities found under {self.generated_root} for split '{split_name}'."
-            )
-        selected_city = city_id or rng.choice(available_cities)
-        selected_scenario = scenario_name or rng.choice(self.scenarios_for_city(selected_city))
-        return self.build_scenario_spec(selected_city, selected_scenario)
-
-    def iter_scenarios(
-        self,
-        split_name: str,
-        scenarios_per_city: int | None = None,
-        max_cities: int | None = None,
-        diversify_single_scenario: bool = False,
-    ) -> list[ScenarioSpec]:
-        scenario_specs: list[ScenarioSpec] = []
-        city_ids = self.load_split(split_name)
-        if max_cities is not None:
-            city_ids = city_ids[:max_cities]
-        for city_index, city_id in enumerate(city_ids):
-            scenario_names = self.scenarios_for_city(city_id)
-            if (
-                diversify_single_scenario
-                and scenarios_per_city == 1
-                and scenario_names
-            ):
-                preferred_order = [
-                    scenario_name
-                    for scenario_name in DEFAULT_SCENARIOS
-                    if scenario_name in scenario_names
-                ]
-                if preferred_order:
-                    scenario_names = [preferred_order[city_index % len(preferred_order)]]
-                else:
-                    scenario_names = [scenario_names[0]]
-            elif scenarios_per_city is not None:
-                scenario_names = scenario_names[:scenarios_per_city]
-            for scenario_name in scenario_names:
-                scenario_specs.append(self.build_scenario_spec(city_id, scenario_name))
-        return scenario_specs
+from __future__ import annotations
+
+import random
+from dataclasses import dataclass
+from pathlib import Path
+
+
+DEFAULT_SCENARIOS = (
+    "normal",
+    "morning_rush",
+    "evening_rush",
+    "accident",
+    "construction",
+    "district_overload",
+    "event_spike",
+)
+
+
+@dataclass(frozen=True)
+class ScenarioSpec:
+    city_id: str
+    scenario_name: str
+    city_dir: Path
+    scenario_dir: Path
+    config_path: Path
+    roadnet_path: Path
+    district_map_path: Path
+    metadata_path: Path
+
+
+class CityFlowDataset:
+    def __init__(
+        self,
+        generated_root: str | Path = "data/generated",
+        splits_root: str | Path = "data/splits",
+    ):
+        self.generated_root = Path(generated_root)
+        self.splits_root = Path(splits_root)
+
+    def discover_cities(self) -> list[str]:
+        return sorted(
+            city_dir.name
+            for city_dir in self.generated_root.glob("city_*")
+            if city_dir.is_dir() and (city_dir / "roadnet.json").exists()
+        )
+
+    def scenarios_for_city(self, city_id: str) -> list[str]:
+        scenario_root = self.generated_root / city_id / "scenarios"
+        return sorted(
+            scenario_dir.name
+            for scenario_dir in scenario_root.iterdir()
+            if scenario_dir.is_dir()
+            and (scenario_dir / "config.json").exists()
+            and (scenario_dir / "flow.json").exists()
+        )
+
+    def load_split(self, split_name: str, create_if_missing: bool = True) -> list[str]:
+        split_path = self.splits_root / f"{split_name}_cities.txt"
+        if not split_path.exists():
+            if not create_if_missing:
+                raise FileNotFoundError(f"Missing split file: {split_path}")
+            self.generate_default_splits()
+
+        split_cities = [
+            line.strip()
+            for line in split_path.read_text().splitlines()
+            if line.strip()
+        ]
+        available_cities = set(self.discover_cities())
+        filtered_cities = [city_id for city_id in split_cities if city_id in available_cities]
+        if filtered_cities:
+            return filtered_cities
+
+        if create_if_missing and available_cities:
+            splits = self.generate_default_splits(overwrite=True)
+            return splits.get(split_name, [])
+
+        return filtered_cities
+
+    def generate_default_splits(
+        self,
+        seed: int = 7,
+        train_ratio: float = 0.7,
+        val_ratio: float = 0.15,
+        overwrite: bool = False,
+    ) -> dict[str, list[str]]:
+        self.splits_root.mkdir(parents=True, exist_ok=True)
+
+        train_path = self.splits_root / "train_cities.txt"
+        val_path = self.splits_root / "val_cities.txt"
+        test_path = self.splits_root / "test_cities.txt"
+        if not overwrite and train_path.exists() and val_path.exists() and test_path.exists():
+            return {
+                "train": self.load_split("train", create_if_missing=False),
+                "val": self.load_split("val", create_if_missing=False),
+                "test": self.load_split("test", create_if_missing=False),
+            }
+
+        city_ids = self.discover_cities()
+        rng = random.Random(seed)
+        rng.shuffle(city_ids)
+
+        num_cities = len(city_ids)
+        if num_cities == 0:
+            splits = {"train": [], "val": [], "test": []}
+        elif num_cities == 1:
+            splits = {"train": city_ids[:], "val": city_ids[:], "test": city_ids[:]}
+        elif num_cities == 2:
+            splits = {
+                "train": sorted(city_ids[:1]),
+                "val": sorted(city_ids[1:2]),
+                "test": sorted(city_ids[:1]),
+            }
+        else:
+            train_count = max(1, int(num_cities * train_ratio))
+            val_count = int(num_cities * val_ratio)
+            if train_count + val_count >= num_cities:
+                val_count = max(0, num_cities - train_count - 1)
+            test_count = num_cities - train_count - val_count
+            if test_count <= 0:
+                test_count = 1
+                if val_count > 0:
+                    val_count -= 1
+                else:
+                    train_count = max(1, train_count - 1)
+
+            splits = {
+                "train": sorted(city_ids[:train_count]),
+                "val": sorted(city_ids[train_count : train_count + val_count]),
+                "test": sorted(city_ids[train_count + val_count :]),
+            }
+
+        for split_name, city_list in splits.items():
+            split_path = self.splits_root / f"{split_name}_cities.txt"
+            split_path.write_text("\n".join(city_list) + "\n")
+
+        return splits
+
+    def build_scenario_spec(self, city_id: str, scenario_name: str) -> ScenarioSpec:
+        city_dir = self.generated_root / city_id
+        scenario_dir = city_dir / "scenarios" / scenario_name
+        return ScenarioSpec(
+            city_id=city_id,
+            scenario_name=scenario_name,
+            city_dir=city_dir,
+            scenario_dir=scenario_dir,
+            config_path=scenario_dir / "config.json",
+            roadnet_path=city_dir / "roadnet.json",
+            district_map_path=city_dir / "district_map.json",
+            metadata_path=city_dir / "metadata.json",
+        )
+
+    def sample_scenario(
+        self,
+        split_name: str,
+        rng: random.Random,
+        city_id: str | None = None,
+        scenario_name: str | None = None,
+    ) -> ScenarioSpec:
+        available_cities = self.load_split(split_name)
+        if not available_cities:
+            available_cities = self.discover_cities()
+        if not available_cities:
+            raise FileNotFoundError(
+                f"No generated cities found under {self.generated_root} for split '{split_name}'."
+            )
+        selected_city = city_id or rng.choice(available_cities)
+        selected_scenario = scenario_name or rng.choice(self.scenarios_for_city(selected_city))
+        return self.build_scenario_spec(selected_city, selected_scenario)
+
+    def iter_scenarios(
+        self,
+        split_name: str,
+        scenarios_per_city: int | None = None,
+        max_cities: int | None = None,
+        diversify_single_scenario: bool = False,
+    ) -> list[ScenarioSpec]:
+        scenario_specs: list[ScenarioSpec] = []
+        city_ids = self.load_split(split_name)
+        if max_cities is not None:
+            city_ids = city_ids[:max_cities]
+        for city_index, city_id in enumerate(city_ids):
+            scenario_names = self.scenarios_for_city(city_id)
+            if (
+                diversify_single_scenario
+                and scenarios_per_city == 1
+                and scenario_names
+            ):
+                preferred_order = [
+                    scenario_name
+                    for scenario_name in DEFAULT_SCENARIOS
+                    if scenario_name in scenario_names
+                ]
+                if preferred_order:
+                    scenario_names = [preferred_order[city_index % len(preferred_order)]]
+                else:
+                    scenario_names = [scenario_names[0]]
+            elif scenarios_per_city is not None:
+                scenario_names = scenario_names[:scenarios_per_city]
+            for scenario_name in scenario_names:
+                scenario_specs.append(self.build_scenario_spec(city_id, scenario_name))
+        return scenario_specs