Run Out

Role

The run_out module adds deceleration and stop points to the ego trajectory in order to prevent collisions with objects that are moving towards the ego vehicle path.

Activation

This module is activated if the launch parameter launch_mvp_run_out_module is set to true.

Inner-workings / Algorithms

This module calculates the times when the ego vehicle and the objects are predicted to overlap each other’s trajectories. These times are then used to decide whether to stop before the overlap or not.

Next we explain the inner-workings of the module in more details.

1. Ego trajectory footprint

In this first step, the trajectory footprint is constructed from the corner points of the vehicle. 4 linestrings are constructed from the 4 corners (front left, front right, rear left, rear right) projected at each trajectory point.

At this step, the footprint size can be adjusted using the ego.lateral_margin and ego.longitudinal_margin parameters.

The following figures show the 4 corner linestrings calculated for the red trajectory.

front left	front right	rear left	rear right

These can be visualized on the debug markers with the ego_footprint_(front|rear)_(left|right) namespaces.

2. Extracting map filtering data

In the second step, we extract geometric information from the vector map that will be used to filter dynamic objects. For each object classification label, we prepare the following sets of geometries based on the parameters defined for that label (objects.{CLASSIFICATION_LABEL}):

• polygons to ignore objects (ignore.polygon_types and ignore.lanelet_subtypes);
  • polygons for the ego trajectory footprint are also added if ignore.if_on_ego_trajectory is set to true.
• polygons to ignore collisions (ignore_collisions.polygon_types and ignore_collisions.lanelet_subtypes);
• segments to cut predicted paths (cut_predicted_paths.polygon_types, cut_predicted_paths.linestring_types, and cut_predicted_paths.lanelet_subtypes).
  • the rear segment of the current ego footprint is also added if cut_predicted_paths.if_crossing_ego_from_behind is set to true.
• segments to strictly cut predicted paths (cut_predicted_paths.strict_polygon_types, cut_predicted_paths.strict_linestring_types, and cut_predicted_paths.strict_lanelet_subtypes).
  • strict cutting means that the cut is always applied, regardless of any preserved distance or duration.

The following figure shows an example where the polygons to ignore objects are shown in blue, to ignore collisions in green, and to cut predicted paths in red.

These geometries can be visualized on the debug markers with the filtering_data_(ignore_objects|ignore_collisions|cut_predicted_paths) namespaces. The classification label corresponding to the published debug markers can be selected with parameter debug.object_label.

3. Dynamic objects filtering

In this step, objects and their predicted paths are filtered based on its classification label and the corresponding parameters objects.{CLASSIFICATION_LABEL}.

An object is ignored if one of the following condition is true:

• its classification label is not in the list defined by the objects.target_labels parameter;
• its velocity is bellow the ignore.stopped_velocity_threshold and ignore.if_stopped is set to true;
• its current footprint is inside one of the polygons prepared in the previous step.

However, if it was decided to stop for the object in the previous iteration, or if a collision was detected with the object, then it cannot be ignored.

If an object is not ignored, its predicted path footprints are generated similarly to the ego footprint First, we only keep predicted paths that have a confidence value above the confidence_filtering.threshold parameter. If, confidence_filtering.only_use_highest is set to true then for each object only the predicted paths that have the higher confidence value are kept. Next, the remaining predicted paths are cut according to the segments prepared in the previous step.

To guarantee that parts of the predicted paths are never ignored, parameters preserved_duration and preserved_distance can be used to set a minimum duration and/or distance that cannot be cut or ignored. This is not applied in the case of the strict cutting.

The following figures shows an example where crosswalks are used to ignore pedestrians and to cut their predicted paths.

debug markers (objects_footprints)	objects of interest

The result of the filtering can be visualized on the debug markers with the objects_footprints namespace which shows in yellow which predicted path will be used for collision checking in the next step.

In addition, the objects of interests markers shows which objects are not ignored and the color will correspond to the decision made towards that object (green for nothing, yellow for slowdown, and red for stop).

4. Collision detection

Now that we prepared the ego trajectory footprint, the dynamic objects, and their predicted paths, we will calculate the times when they are predicted to collide.

The following operations are performed for each object that was not ignored in the previous iteration.

First, we calculate the intersections between each pair of linestrings between the ego and object footprints. For each intersection, we calculate the corresponding point, the time when ego and the object are predicted to reach that point, and the location of that point on the ego footprint (e.g., on the rear left linestring).

All these intersections are then combined into intervals representing when the overlap between the ego trajectory and object predicted paths starts and ends. An overlap is represented by the entering and exiting intersections for both ego and the object.

File truncated at 100 lines see the full file

Changelog for package autoware_motion_velocity_run_out_module

0.47.0 (2025-08-11)

• fix(run_out): add missing ament_auto_package in CMakeList (#11096)
• style(pre-commit): update to clang-format-20 (#11088) Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
• feat(run_out): add parameters to select which debug markers to publish (#11082)
• feat(run_out): add planning factors (#10892)
• chore(run_out): add Zulfaqar Azmi as maintainer (#10896)
• feat(run_out): add option for strict cutting of predicted paths (#10887)
• Contributors: Maxime CLEMENT, Mete Fatih Cırıt

0.46.0 (2025-06-20)

• Merge remote-tracking branch 'upstream/main' into tmp/TaikiYamada/bump_version_base

• fix(run_out): fix numerical stability in run_out interpolation (#10808)

  • fix(run_out): fix numerical stability in run_out interpolation

  * fix build ---------

• feat(run_out): option to preserve parts of ignored predicted paths (#10754)

• chore(run_out): add Alqudah Mohammad as maintainer (#10762)

• fix(run_out): guard against decreasing ego trajectory times (#10746)

• feat(autoware_motion_velocity_planner): only wait for required subscriptions (#10732)

• Contributors: Maxime CLEMENT, Ryohsuke Mitsudome, TaikiYamada4, Yuxuan Liu

0.45.0 (2025-05-22)

• Merge remote-tracking branch 'origin/main' into tmp/notbot/bump_version_base
• fix(motion_velocity_planner): add missing header (#10560)
• fix(motion_velocity_planner): remove unused functions (#10563)
• fix(motion_velocity_planner): remove unused function (#10564)
• fix(motion_velocity_planner/run_out): fix tf2 include (.hpp->.h) (#10548)
• chore(motion_velocity_run_out): add diagnostic_updater for dependency resolve (#10535)
• feat(motion_velocity_planner): add new run_out module (#10388)
• Contributors: Mamoru Sobue, Masaki Baba, Maxime CLEMENT, Ryuta Kambe, TaikiYamada4