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)becomesMetricCondition(m, ..., max_ng_seconds=seconds). Note the meaning moves from "held forsecondsin a row" to "held forsecondsin all".- A
MetricConditionwrapped inNotCondition,AndCondition,OrConditionorStickyCondition, or registered withregister_pass_condition, is refused: register it on its own withregister_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
CollisionConditionas 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 importsCameraRecorderor the drawing helpers: remove that. These are gone, and passing them is aTypeErroror anImportError. - Seeing runs: install the converter and the viewer
(
pip install 'autoware-carla-scenario[rerun,viewer]') and run withrerun.enabled=true: each run's log is converted intoX.rrdbeside it as the run ends, the result (rerun_recording) names it, and the viewer's scenario page shows it. Open it withrerun X.rrd. Runs made without it convert afterwards withpython -m autoware_carla_scenario.rerun outputs/...(a session, a sweep, or oneX.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.