Skip to content

Migrating

visibility.at_quantile is gone

The helper was exported but nothing read it: the weather rules' quantities take their quantiles from their own distributions (Weather rules). Code importing at_quantile writes its own; it was low + q * (high - low), with q the quantile clamped to [0, 1] (#2251).

The same release refuses, as the config is read, what used to fail later (#2251): a blank weather-rules path (environment.rules, its default or a vehicles entry) is refused naming the key, rather than read as the directory the run started in; and PerceptionFaultInjectionAction refuses the ego under any of its role names (ego or hero, in any case), not only Ego.

The driver's steering angles default to null

DriverControlSpec.max_steer_angle_deg and yaw_rate_trim_limit_deg now default to None instead of 56.0 and 25.0, and the spec has their radian twins, max_steer_angle_rad and yaw_rate_trim_limit_rad, also None (Driver interface). Null is the controller's default, so a run steers as before; but the degrees used to win silently over a driver.control.max_steer_angle_rad override, and one angle set both ways is now refused. Code reading the spec's max_steer_angle_deg for a number reads the effective angle from the controller's config instead: ControlConfig.from_mapping(dataclasses.asdict(spec)).max_steer_angle_rad. A config group of your own that sets max_steer_angle_deg keeps working, unless it also sets max_steer_angle_rad.

The same release refuses as the config is read what used to fail later or pass silently (#2241): a null driver.control (or ros2.control) setting is now its default rather than an error; driver.policy and driver.map_dir must be a non-empty string or null; driver.map_formats must be a list of known format names, with t4 only beside driver.t4_scene; and a HILS device's url must be non-blank text, its codec neither empty nor a bare NAME: (HILS).

A T4 dataset's LiDAR intensity is on the 0-255 scale

A run's T4 dataset (t4.enabled) wrote its sweeps' intensity on CARLA's [0, 1] scale, which T4's readers take for a nearly black cloud. It is now on T4's 0-255 scale, as Autoware's point clouds and the T4Scenes' sweeps are (T4 Dataset): CARLA's value times 255. Code reading an earlier dataset's .pcd.bin files that scaled the intensity itself drops that; datasets written before stay on [0, 1] (#2237).

An adversity trigger's draws have a stream of their own

AdversityFeasibleCondition, the default trigger of every adversarial action, now seeds its draws (a jaywalker's speed, a stopped crosser's wait) from its seed and a key of its entity, kind and label (Adversity, adversity.nade.trigger_stream_seed), instead of random.Random(seed). Two actions following the run's seed no longer draw the same numbers, nor NADE's (#2226). A run still repeats from its seed, but the draws for any given seed, whether the run's or an explicit seed=, differ from those of earlier releases: a scenario that pinned a jaywalker's path or a crosser's wait to a seed needs its expectation updated. Renaming an action's label or entity also changes its draws.

debug_markers.DRIVEN_PATH_COLOR is gone

The colour was exported for a viewer to draw the driven path in, but nothing read it: the Rerun converter colours the path itself. Code importing DRIVEN_PATH_COLOR defines its own colour instead; it was (255, 128, 0).

To 23.0.0: metrics are judged once the run is over

MetricCondition is now a fail condition judged after the run, on metrics computed from the frames the run recorded (Metrics), instead of a condition checked every tick. A run fails when the metric met the rule for more than max_ng_seconds (new, default 0: at the first frame that does) in all.

What to change

  • PersistentCondition(MetricCondition(m, ...), seconds) becomes MetricCondition(m, ..., max_ng_seconds=seconds). Note the meaning moves from "held for seconds in a row" to "held for seconds in all".
  • A MetricCondition wrapped in NotCondition, AndCondition, OrCondition or StickyCondition, or registered with register_pass_condition, is refused: register it on its own with register_fail_condition.
  • A metric condition no longer ends a run early: a run that collides runs on to its other conditions or its timeout, and is failed on the metric afterwards, at the time the metric went NG. Give a scenario that should stop at a collision a CollisionCondition as well.

SUMO's outputs are the run's own

The SUMO backend (traffic=sumo) writes its log, its generated demand and, with fcd_output, fcd.xml and clock.csv to <output>/{stem}.sumo/, named by the run's file stem like its {stem}_result.json, instead of <output>/sumo/, which every run of a batch overwrote (Traffic Backends). A tool reading <output>/sumo/fcd.xml reads <output>/{stem}.sumo/fcd.xml: the stem is the result file's name without _result.json. A backend prepared without a run (TrafficContext with no file_stem) still writes to <output>/sumo/.

The Speed card's Longitudinal and Lateral follow the entity

The editor's Speed card (type_id: speed) now measures its Longitudinal and Lateral components along its own entity's heading, as the Acceleration card always has: longitudinal is the speed along the way the entity faces (negative while reversing), lateral the speed to its left. They used to be the world's x and y, so "longitudinal speed above 5" held only while the entity drove east (#1089).

A saved document needs no edit, but one that picks Longitudinal or Lateral on a Speed card now means the entity's own frame. One written to test a world direction meant it only by accident; to keep it, write that condition in Python, where SpeedCondition still defaults to SpeedCoordinateSystem.WORLD. Magnitude is unchanged.

The viewer and the editor bind 127.0.0.1 by default

viewer and scenario-editor now take command-line options (--help, --host, --port, and the directories they serve; see usage and the editor's configuration). They used to ignore every argument and bind 0.0.0.0; both now bind 127.0.0.1, because neither has authentication and the viewer's API starts scenario runs and SLURM submissions.

To serve other machines as before, say so: uv run viewer --host 0.0.0.0, or VIEWER_HOST=0.0.0.0 / SCENARIO_EDITOR_HOST=0.0.0.0 in the environment, which still works (a flag wins over it). Either prints a warning on stderr.

To 15.0.0: no video, the trajectory log instead

15.0.0 removes the video a run used to render ({Scenario}.mp4). After each run, the runner replayed the CARLA recording on the same server with an RGB camera and encoded the frames with ffmpeg. That took about as long as the run, and the next case waited for it. It also needed ffmpeg on every machine that ran scenarios. A run is now seen through its trajectory log, which every run already writes, from a Rerun recording made out of it.

What is gone

Removed Instead
{Scenario}.mp4 after each run {Scenario}.rrd, a Rerun recording of {Scenario}.trajectory.jsonl made as the run ends (rerun.enabled=true, the rerun extra), opened in the Rerun viewer (Seeing a run)
video.width, video.height (and video.enabled, which never shipped in a release) Nothing to set. A run that sets one warns that it is ignored
CameraRecorder, autoware_carla_scenario.camera_recorder, check_video_size, DEFAULT_IMAGE_WIDTH/HEIGHT —
ScenarioRunner(video_width=, video_height=), ScenarioQueue(video_width=, video_height=), run_scenario_with_queue(video_size=) Drop the arguments
ScenarioRunner._render_video_from_recording, DebugMarkerLog, DrivenPathDrawer, draw_debug_markers The trajectory log's markers records (the ego's plan) and its ticks (the path it drove)
SpectatorCameraConfig, BaseScenario._spectator_camera_config (where the video's camera went) — : BaseScenario.follow_with_spectator() still moves CARLA's spectator, and takes the same arguments
The viewer's video player and its /video/... route The scenario page shows the run in an embedded Rerun web viewer (/recording/...rrd): the recording rerun.enabled=true made as the run ended, else one the viewer makes on demand
The ffmpeg-python dependency, and ffmpeg itself —
with-ffmpeg of the pack-scenario-image action —

The CARLA recording ({Scenario}.log) is still written: CARLA's replayer (client.replay_file()) plays it back on a server running the same map. The ego's debug markers are still collected (EgoVehicle.debug_markers()), and are written into the trajectory log.

What to change

  • Command lines and configs that set video.*: drop it. It is accepted, so an old script still runs, and warned about.
  • Code that passes video_width/video_height/video_size, or imports CameraRecorder or the drawing helpers: remove that. These are gone, and passing them is a TypeError or an ImportError.
  • Seeing runs: install the converter and the viewer (pip install 'autoware-carla-scenario[rerun,viewer]') and run with rerun.enabled=true: each run's log is converted into X.rrd beside it as the run ends, the result (rerun_recording) names it, and the viewer's scenario page shows it. Open it with rerun X.rrd. Runs made without it convert afterwards with python -m autoware_carla_scenario.rerun outputs/... (a session, a sweep, or one X.trajectory.jsonl). The log carries the map it was recorded on (paths and SHA-256 of the Lanelet2 and OpenDRIVE files), the warm-up, the ego's plan, every condition's state and the verdict (Trajectory Log).
  • Container images built with with-ffmpeg: true: drop the input.