Package Summary
Tags | No category tags. |
Version | 0.1.0 |
License | Apache License 2.0 |
Build type | AMENT_CMAKE |
Use | RECOMMENDED |
Repository Summary
Description | |
Checkout URI | https://github.com/ieiauto/autodrrt.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-05-30 |
Dev Status | UNKNOWN |
Released | UNRELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Tomohito Ando
- Makoto Kurihara
- Tomoya Kimura
- Shumpei Wakabayashi
- Takayuki Murooka
Authors
- Tomohito Ando
Run Out
Role
run_out
is the module that decelerates and stops for dynamic obstacles such as pedestrians and bicycles.
Activation Timing
This module is activated if launch_run_out
becomes true
Inner-workings / Algorithms
Flow chart
@startuml
title modifyPathVelocity
start
partition "Preprocess path" {
:Calculate the expected target velocity for ego vehicle;
:Extend path;
:Trim path from ego position;
}
partition "Preprocess obstacles" {
:Create data of abstracted dynamic obstacles;
:Exclude obstacles outside of partition lanelet;
}
partition "Collision_detection" {
:Detect collision with dynamic obstacles;
}
partition "Insert velocity" {
:Insert velocity to decelerate for obstacles;
:Limit velocity with specified jerk and acc limit;
}
stop
@enduml
Preprocess path
Calculate the expected target velocity for ego vehicle
Calculate the expected target velocity for the ego vehicle path to calculate time to collision with obstacles more precisely. The expected target velocity is calculated with motion velocity smoother module by using current velocity, current acceleration and velocity limits directed by the map and external API.
Extend the path
The path is extended by the length of base link to front to consider obstacles after the goal.
Trim path from ego position
The path is trimmed from ego position to a certain distance to reduce calculation time.
Trimmed distance is specified by parameter of detection_distance
.
Preprocess obstacles
Create data of abstracted dynamic obstacle
This module can handle multiple types of obstacles by creating abstracted dynamic obstacle data layer. Currently we have 3 types of detection method (Object, ObjectWithoutPath, Points) to create abstracted obstacle data.
Abstracted dynamic obstacle
Abstracted obstacle data has following information.
Name | Type | Description |
---|---|---|
pose | geometry_msgs::msg::Pose |
pose of the obstacle |
classifications | std::vector<autoware_auto_perception_msgs::msg::ObjectClassification> |
classifications with probability |
shape | autoware_auto_perception_msgs::msg::Shape |
shape of the obstacle |
predicted_paths | std::vector<DynamicObstacle::PredictedPath> |
predicted paths with confidence. this data doesn’t have time step because we use minimum and maximum velocity instead. |
min_velocity_mps | float |
minimum velocity of the obstacle. specified by parameter of dynamic_obstacle.min_vel_kmph
|
max_velocity_mps | float |
maximum velocity of the obstacle. specified by parameter of dynamic_obstacle.max_vel_kmph
|
Enter the maximum/minimum velocity of the object as a parameter, adding enough margin to the expected velocity. This parameter is used to create polygons for collision detection.
Future work: Determine the maximum/minimum velocity from the estimated velocity with covariance of the object
3 types of detection method
We have 3 types of detection method to meet different safety and availability requirements. The characteristics of them are shown in the table below.
Method of Object
has high availability (less false positive) because it detects only objects whose predicted path is on the lane. However, sometimes it is not safe because perception may fail to detect obstacles or generate incorrect predicted paths.
On the other hand, method of Points
has high safety (less false negative) because it uses pointcloud as input. Since points don’t have a predicted path, the path that moves in the direction normal to the path of ego vehicle is considered to be the predicted path of abstracted dynamic obstacle data. However, without proper adjustment of filter of points, it may detect a lot of points and it will result in very low availability.
Method of ObjectWithoutPath
has the characteristics of an intermediate of Object
and Points
.
Method | Description |
---|---|
Object | use an object with the predicted path for collision detection. |
ObjectWithoutPath | use an object but not use the predicted path for collision detection. replace the path assuming that an object jumps out to the lane at specified velocity. |
Points | use filtered points for collision detection. the path is created assuming that points jump out to the lane. points are regarded as an small circular shaped obstacle. |
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Name |
---|
eigen |
libboost-dev |
Dependant Packages
Name | Deps |
---|---|
behavior_velocity_planner |
Launch files
Messages
Services
Plugins
Recent questions tagged behavior_velocity_run_out_module at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 0.1.0 |
License | Apache License 2.0 |
Build type | AMENT_CMAKE |
Use | RECOMMENDED |
Repository Summary
Description | |
Checkout URI | https://github.com/ieiauto/autodrrt.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-05-30 |
Dev Status | UNKNOWN |
Released | UNRELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Tomohito Ando
- Makoto Kurihara
- Tomoya Kimura
- Shumpei Wakabayashi
- Takayuki Murooka
Authors
- Tomohito Ando
Run Out
Role
run_out
is the module that decelerates and stops for dynamic obstacles such as pedestrians and bicycles.
Activation Timing
This module is activated if launch_run_out
becomes true
Inner-workings / Algorithms
Flow chart
@startuml
title modifyPathVelocity
start
partition "Preprocess path" {
:Calculate the expected target velocity for ego vehicle;
:Extend path;
:Trim path from ego position;
}
partition "Preprocess obstacles" {
:Create data of abstracted dynamic obstacles;
:Exclude obstacles outside of partition lanelet;
}
partition "Collision_detection" {
:Detect collision with dynamic obstacles;
}
partition "Insert velocity" {
:Insert velocity to decelerate for obstacles;
:Limit velocity with specified jerk and acc limit;
}
stop
@enduml
Preprocess path
Calculate the expected target velocity for ego vehicle
Calculate the expected target velocity for the ego vehicle path to calculate time to collision with obstacles more precisely. The expected target velocity is calculated with motion velocity smoother module by using current velocity, current acceleration and velocity limits directed by the map and external API.
Extend the path
The path is extended by the length of base link to front to consider obstacles after the goal.
Trim path from ego position
The path is trimmed from ego position to a certain distance to reduce calculation time.
Trimmed distance is specified by parameter of detection_distance
.
Preprocess obstacles
Create data of abstracted dynamic obstacle
This module can handle multiple types of obstacles by creating abstracted dynamic obstacle data layer. Currently we have 3 types of detection method (Object, ObjectWithoutPath, Points) to create abstracted obstacle data.
Abstracted dynamic obstacle
Abstracted obstacle data has following information.
Name | Type | Description |
---|---|---|
pose | geometry_msgs::msg::Pose |
pose of the obstacle |
classifications | std::vector<autoware_auto_perception_msgs::msg::ObjectClassification> |
classifications with probability |
shape | autoware_auto_perception_msgs::msg::Shape |
shape of the obstacle |
predicted_paths | std::vector<DynamicObstacle::PredictedPath> |
predicted paths with confidence. this data doesn’t have time step because we use minimum and maximum velocity instead. |
min_velocity_mps | float |
minimum velocity of the obstacle. specified by parameter of dynamic_obstacle.min_vel_kmph
|
max_velocity_mps | float |
maximum velocity of the obstacle. specified by parameter of dynamic_obstacle.max_vel_kmph
|
Enter the maximum/minimum velocity of the object as a parameter, adding enough margin to the expected velocity. This parameter is used to create polygons for collision detection.
Future work: Determine the maximum/minimum velocity from the estimated velocity with covariance of the object
3 types of detection method
We have 3 types of detection method to meet different safety and availability requirements. The characteristics of them are shown in the table below.
Method of Object
has high availability (less false positive) because it detects only objects whose predicted path is on the lane. However, sometimes it is not safe because perception may fail to detect obstacles or generate incorrect predicted paths.
On the other hand, method of Points
has high safety (less false negative) because it uses pointcloud as input. Since points don’t have a predicted path, the path that moves in the direction normal to the path of ego vehicle is considered to be the predicted path of abstracted dynamic obstacle data. However, without proper adjustment of filter of points, it may detect a lot of points and it will result in very low availability.
Method of ObjectWithoutPath
has the characteristics of an intermediate of Object
and Points
.
Method | Description |
---|---|
Object | use an object with the predicted path for collision detection. |
ObjectWithoutPath | use an object but not use the predicted path for collision detection. replace the path assuming that an object jumps out to the lane at specified velocity. |
Points | use filtered points for collision detection. the path is created assuming that points jump out to the lane. points are regarded as an small circular shaped obstacle. |
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Name |
---|
eigen |
libboost-dev |
Dependant Packages
Name | Deps |
---|---|
behavior_velocity_planner |
Launch files
Messages
Services
Plugins
Recent questions tagged behavior_velocity_run_out_module at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 0.1.0 |
License | Apache License 2.0 |
Build type | AMENT_CMAKE |
Use | RECOMMENDED |
Repository Summary
Description | |
Checkout URI | https://github.com/ieiauto/autodrrt.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-05-30 |
Dev Status | UNKNOWN |
Released | UNRELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Tomohito Ando
- Makoto Kurihara
- Tomoya Kimura
- Shumpei Wakabayashi
- Takayuki Murooka
Authors
- Tomohito Ando
Run Out
Role
run_out
is the module that decelerates and stops for dynamic obstacles such as pedestrians and bicycles.
Activation Timing
This module is activated if launch_run_out
becomes true
Inner-workings / Algorithms
Flow chart
@startuml
title modifyPathVelocity
start
partition "Preprocess path" {
:Calculate the expected target velocity for ego vehicle;
:Extend path;
:Trim path from ego position;
}
partition "Preprocess obstacles" {
:Create data of abstracted dynamic obstacles;
:Exclude obstacles outside of partition lanelet;
}
partition "Collision_detection" {
:Detect collision with dynamic obstacles;
}
partition "Insert velocity" {
:Insert velocity to decelerate for obstacles;
:Limit velocity with specified jerk and acc limit;
}
stop
@enduml
Preprocess path
Calculate the expected target velocity for ego vehicle
Calculate the expected target velocity for the ego vehicle path to calculate time to collision with obstacles more precisely. The expected target velocity is calculated with motion velocity smoother module by using current velocity, current acceleration and velocity limits directed by the map and external API.
Extend the path
The path is extended by the length of base link to front to consider obstacles after the goal.
Trim path from ego position
The path is trimmed from ego position to a certain distance to reduce calculation time.
Trimmed distance is specified by parameter of detection_distance
.
Preprocess obstacles
Create data of abstracted dynamic obstacle
This module can handle multiple types of obstacles by creating abstracted dynamic obstacle data layer. Currently we have 3 types of detection method (Object, ObjectWithoutPath, Points) to create abstracted obstacle data.
Abstracted dynamic obstacle
Abstracted obstacle data has following information.
Name | Type | Description |
---|---|---|
pose | geometry_msgs::msg::Pose |
pose of the obstacle |
classifications | std::vector<autoware_auto_perception_msgs::msg::ObjectClassification> |
classifications with probability |
shape | autoware_auto_perception_msgs::msg::Shape |
shape of the obstacle |
predicted_paths | std::vector<DynamicObstacle::PredictedPath> |
predicted paths with confidence. this data doesn’t have time step because we use minimum and maximum velocity instead. |
min_velocity_mps | float |
minimum velocity of the obstacle. specified by parameter of dynamic_obstacle.min_vel_kmph
|
max_velocity_mps | float |
maximum velocity of the obstacle. specified by parameter of dynamic_obstacle.max_vel_kmph
|
Enter the maximum/minimum velocity of the object as a parameter, adding enough margin to the expected velocity. This parameter is used to create polygons for collision detection.
Future work: Determine the maximum/minimum velocity from the estimated velocity with covariance of the object
3 types of detection method
We have 3 types of detection method to meet different safety and availability requirements. The characteristics of them are shown in the table below.
Method of Object
has high availability (less false positive) because it detects only objects whose predicted path is on the lane. However, sometimes it is not safe because perception may fail to detect obstacles or generate incorrect predicted paths.
On the other hand, method of Points
has high safety (less false negative) because it uses pointcloud as input. Since points don’t have a predicted path, the path that moves in the direction normal to the path of ego vehicle is considered to be the predicted path of abstracted dynamic obstacle data. However, without proper adjustment of filter of points, it may detect a lot of points and it will result in very low availability.
Method of ObjectWithoutPath
has the characteristics of an intermediate of Object
and Points
.
Method | Description |
---|---|
Object | use an object with the predicted path for collision detection. |
ObjectWithoutPath | use an object but not use the predicted path for collision detection. replace the path assuming that an object jumps out to the lane at specified velocity. |
Points | use filtered points for collision detection. the path is created assuming that points jump out to the lane. points are regarded as an small circular shaped obstacle. |
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Name |
---|
eigen |
libboost-dev |
Dependant Packages
Name | Deps |
---|---|
behavior_velocity_planner |
Launch files
Messages
Services
Plugins
Recent questions tagged behavior_velocity_run_out_module at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 0.1.0 |
License | Apache License 2.0 |
Build type | AMENT_CMAKE |
Use | RECOMMENDED |
Repository Summary
Description | |
Checkout URI | https://github.com/ieiauto/autodrrt.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-05-30 |
Dev Status | UNKNOWN |
Released | UNRELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Tomohito Ando
- Makoto Kurihara
- Tomoya Kimura
- Shumpei Wakabayashi
- Takayuki Murooka
Authors
- Tomohito Ando
Run Out
Role
run_out
is the module that decelerates and stops for dynamic obstacles such as pedestrians and bicycles.
Activation Timing
This module is activated if launch_run_out
becomes true
Inner-workings / Algorithms
Flow chart
@startuml
title modifyPathVelocity
start
partition "Preprocess path" {
:Calculate the expected target velocity for ego vehicle;
:Extend path;
:Trim path from ego position;
}
partition "Preprocess obstacles" {
:Create data of abstracted dynamic obstacles;
:Exclude obstacles outside of partition lanelet;
}
partition "Collision_detection" {
:Detect collision with dynamic obstacles;
}
partition "Insert velocity" {
:Insert velocity to decelerate for obstacles;
:Limit velocity with specified jerk and acc limit;
}
stop
@enduml
Preprocess path
Calculate the expected target velocity for ego vehicle
Calculate the expected target velocity for the ego vehicle path to calculate time to collision with obstacles more precisely. The expected target velocity is calculated with motion velocity smoother module by using current velocity, current acceleration and velocity limits directed by the map and external API.
Extend the path
The path is extended by the length of base link to front to consider obstacles after the goal.
Trim path from ego position
The path is trimmed from ego position to a certain distance to reduce calculation time.
Trimmed distance is specified by parameter of detection_distance
.
Preprocess obstacles
Create data of abstracted dynamic obstacle
This module can handle multiple types of obstacles by creating abstracted dynamic obstacle data layer. Currently we have 3 types of detection method (Object, ObjectWithoutPath, Points) to create abstracted obstacle data.
Abstracted dynamic obstacle
Abstracted obstacle data has following information.
Name | Type | Description |
---|---|---|
pose | geometry_msgs::msg::Pose |
pose of the obstacle |
classifications | std::vector<autoware_auto_perception_msgs::msg::ObjectClassification> |
classifications with probability |
shape | autoware_auto_perception_msgs::msg::Shape |
shape of the obstacle |
predicted_paths | std::vector<DynamicObstacle::PredictedPath> |
predicted paths with confidence. this data doesn’t have time step because we use minimum and maximum velocity instead. |
min_velocity_mps | float |
minimum velocity of the obstacle. specified by parameter of dynamic_obstacle.min_vel_kmph
|
max_velocity_mps | float |
maximum velocity of the obstacle. specified by parameter of dynamic_obstacle.max_vel_kmph
|
Enter the maximum/minimum velocity of the object as a parameter, adding enough margin to the expected velocity. This parameter is used to create polygons for collision detection.
Future work: Determine the maximum/minimum velocity from the estimated velocity with covariance of the object
3 types of detection method
We have 3 types of detection method to meet different safety and availability requirements. The characteristics of them are shown in the table below.
Method of Object
has high availability (less false positive) because it detects only objects whose predicted path is on the lane. However, sometimes it is not safe because perception may fail to detect obstacles or generate incorrect predicted paths.
On the other hand, method of Points
has high safety (less false negative) because it uses pointcloud as input. Since points don’t have a predicted path, the path that moves in the direction normal to the path of ego vehicle is considered to be the predicted path of abstracted dynamic obstacle data. However, without proper adjustment of filter of points, it may detect a lot of points and it will result in very low availability.
Method of ObjectWithoutPath
has the characteristics of an intermediate of Object
and Points
.
Method | Description |
---|---|
Object | use an object with the predicted path for collision detection. |
ObjectWithoutPath | use an object but not use the predicted path for collision detection. replace the path assuming that an object jumps out to the lane at specified velocity. |
Points | use filtered points for collision detection. the path is created assuming that points jump out to the lane. points are regarded as an small circular shaped obstacle. |
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Name |
---|
eigen |
libboost-dev |
Dependant Packages
Name | Deps |
---|---|
behavior_velocity_planner |
Launch files
Messages
Services
Plugins
Recent questions tagged behavior_velocity_run_out_module at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 0.1.0 |
License | Apache License 2.0 |
Build type | AMENT_CMAKE |
Use | RECOMMENDED |
Repository Summary
Description | |
Checkout URI | https://github.com/ieiauto/autodrrt.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-05-30 |
Dev Status | UNKNOWN |
Released | UNRELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Tomohito Ando
- Makoto Kurihara
- Tomoya Kimura
- Shumpei Wakabayashi
- Takayuki Murooka
Authors
- Tomohito Ando
Run Out
Role
run_out
is the module that decelerates and stops for dynamic obstacles such as pedestrians and bicycles.
Activation Timing
This module is activated if launch_run_out
becomes true
Inner-workings / Algorithms
Flow chart
@startuml
title modifyPathVelocity
start
partition "Preprocess path" {
:Calculate the expected target velocity for ego vehicle;
:Extend path;
:Trim path from ego position;
}
partition "Preprocess obstacles" {
:Create data of abstracted dynamic obstacles;
:Exclude obstacles outside of partition lanelet;
}
partition "Collision_detection" {
:Detect collision with dynamic obstacles;
}
partition "Insert velocity" {
:Insert velocity to decelerate for obstacles;
:Limit velocity with specified jerk and acc limit;
}
stop
@enduml
Preprocess path
Calculate the expected target velocity for ego vehicle
Calculate the expected target velocity for the ego vehicle path to calculate time to collision with obstacles more precisely. The expected target velocity is calculated with motion velocity smoother module by using current velocity, current acceleration and velocity limits directed by the map and external API.
Extend the path
The path is extended by the length of base link to front to consider obstacles after the goal.
Trim path from ego position
The path is trimmed from ego position to a certain distance to reduce calculation time.
Trimmed distance is specified by parameter of detection_distance
.
Preprocess obstacles
Create data of abstracted dynamic obstacle
This module can handle multiple types of obstacles by creating abstracted dynamic obstacle data layer. Currently we have 3 types of detection method (Object, ObjectWithoutPath, Points) to create abstracted obstacle data.
Abstracted dynamic obstacle
Abstracted obstacle data has following information.
Name | Type | Description |
---|---|---|
pose | geometry_msgs::msg::Pose |
pose of the obstacle |
classifications | std::vector<autoware_auto_perception_msgs::msg::ObjectClassification> |
classifications with probability |
shape | autoware_auto_perception_msgs::msg::Shape |
shape of the obstacle |
predicted_paths | std::vector<DynamicObstacle::PredictedPath> |
predicted paths with confidence. this data doesn’t have time step because we use minimum and maximum velocity instead. |
min_velocity_mps | float |
minimum velocity of the obstacle. specified by parameter of dynamic_obstacle.min_vel_kmph
|
max_velocity_mps | float |
maximum velocity of the obstacle. specified by parameter of dynamic_obstacle.max_vel_kmph
|
Enter the maximum/minimum velocity of the object as a parameter, adding enough margin to the expected velocity. This parameter is used to create polygons for collision detection.
Future work: Determine the maximum/minimum velocity from the estimated velocity with covariance of the object
3 types of detection method
We have 3 types of detection method to meet different safety and availability requirements. The characteristics of them are shown in the table below.
Method of Object
has high availability (less false positive) because it detects only objects whose predicted path is on the lane. However, sometimes it is not safe because perception may fail to detect obstacles or generate incorrect predicted paths.
On the other hand, method of Points
has high safety (less false negative) because it uses pointcloud as input. Since points don’t have a predicted path, the path that moves in the direction normal to the path of ego vehicle is considered to be the predicted path of abstracted dynamic obstacle data. However, without proper adjustment of filter of points, it may detect a lot of points and it will result in very low availability.
Method of ObjectWithoutPath
has the characteristics of an intermediate of Object
and Points
.
Method | Description |
---|---|
Object | use an object with the predicted path for collision detection. |
ObjectWithoutPath | use an object but not use the predicted path for collision detection. replace the path assuming that an object jumps out to the lane at specified velocity. |
Points | use filtered points for collision detection. the path is created assuming that points jump out to the lane. points are regarded as an small circular shaped obstacle. |
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Name |
---|
eigen |
libboost-dev |
Dependant Packages
Name | Deps |
---|---|
behavior_velocity_planner |
Launch files
Messages
Services
Plugins
Recent questions tagged behavior_velocity_run_out_module at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 0.1.0 |
License | Apache License 2.0 |
Build type | AMENT_CMAKE |
Use | RECOMMENDED |
Repository Summary
Description | |
Checkout URI | https://github.com/ieiauto/autodrrt.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-05-30 |
Dev Status | UNKNOWN |
Released | UNRELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Tomohito Ando
- Makoto Kurihara
- Tomoya Kimura
- Shumpei Wakabayashi
- Takayuki Murooka
Authors
- Tomohito Ando
Run Out
Role
run_out
is the module that decelerates and stops for dynamic obstacles such as pedestrians and bicycles.
Activation Timing
This module is activated if launch_run_out
becomes true
Inner-workings / Algorithms
Flow chart
@startuml
title modifyPathVelocity
start
partition "Preprocess path" {
:Calculate the expected target velocity for ego vehicle;
:Extend path;
:Trim path from ego position;
}
partition "Preprocess obstacles" {
:Create data of abstracted dynamic obstacles;
:Exclude obstacles outside of partition lanelet;
}
partition "Collision_detection" {
:Detect collision with dynamic obstacles;
}
partition "Insert velocity" {
:Insert velocity to decelerate for obstacles;
:Limit velocity with specified jerk and acc limit;
}
stop
@enduml
Preprocess path
Calculate the expected target velocity for ego vehicle
Calculate the expected target velocity for the ego vehicle path to calculate time to collision with obstacles more precisely. The expected target velocity is calculated with motion velocity smoother module by using current velocity, current acceleration and velocity limits directed by the map and external API.
Extend the path
The path is extended by the length of base link to front to consider obstacles after the goal.
Trim path from ego position
The path is trimmed from ego position to a certain distance to reduce calculation time.
Trimmed distance is specified by parameter of detection_distance
.
Preprocess obstacles
Create data of abstracted dynamic obstacle
This module can handle multiple types of obstacles by creating abstracted dynamic obstacle data layer. Currently we have 3 types of detection method (Object, ObjectWithoutPath, Points) to create abstracted obstacle data.
Abstracted dynamic obstacle
Abstracted obstacle data has following information.
Name | Type | Description |
---|---|---|
pose | geometry_msgs::msg::Pose |
pose of the obstacle |
classifications | std::vector<autoware_auto_perception_msgs::msg::ObjectClassification> |
classifications with probability |
shape | autoware_auto_perception_msgs::msg::Shape |
shape of the obstacle |
predicted_paths | std::vector<DynamicObstacle::PredictedPath> |
predicted paths with confidence. this data doesn’t have time step because we use minimum and maximum velocity instead. |
min_velocity_mps | float |
minimum velocity of the obstacle. specified by parameter of dynamic_obstacle.min_vel_kmph
|
max_velocity_mps | float |
maximum velocity of the obstacle. specified by parameter of dynamic_obstacle.max_vel_kmph
|
Enter the maximum/minimum velocity of the object as a parameter, adding enough margin to the expected velocity. This parameter is used to create polygons for collision detection.
Future work: Determine the maximum/minimum velocity from the estimated velocity with covariance of the object
3 types of detection method
We have 3 types of detection method to meet different safety and availability requirements. The characteristics of them are shown in the table below.
Method of Object
has high availability (less false positive) because it detects only objects whose predicted path is on the lane. However, sometimes it is not safe because perception may fail to detect obstacles or generate incorrect predicted paths.
On the other hand, method of Points
has high safety (less false negative) because it uses pointcloud as input. Since points don’t have a predicted path, the path that moves in the direction normal to the path of ego vehicle is considered to be the predicted path of abstracted dynamic obstacle data. However, without proper adjustment of filter of points, it may detect a lot of points and it will result in very low availability.
Method of ObjectWithoutPath
has the characteristics of an intermediate of Object
and Points
.
Method | Description |
---|---|
Object | use an object with the predicted path for collision detection. |
ObjectWithoutPath | use an object but not use the predicted path for collision detection. replace the path assuming that an object jumps out to the lane at specified velocity. |
Points | use filtered points for collision detection. the path is created assuming that points jump out to the lane. points are regarded as an small circular shaped obstacle. |
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Name |
---|
eigen |
libboost-dev |
Dependant Packages
Name | Deps |
---|---|
behavior_velocity_planner |
Launch files
Messages
Services
Plugins
Recent questions tagged behavior_velocity_run_out_module at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 0.1.0 |
License | Apache License 2.0 |
Build type | AMENT_CMAKE |
Use | RECOMMENDED |
Repository Summary
Description | |
Checkout URI | https://github.com/ieiauto/autodrrt.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-05-30 |
Dev Status | UNKNOWN |
Released | UNRELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Tomohito Ando
- Makoto Kurihara
- Tomoya Kimura
- Shumpei Wakabayashi
- Takayuki Murooka
Authors
- Tomohito Ando
Run Out
Role
run_out
is the module that decelerates and stops for dynamic obstacles such as pedestrians and bicycles.
Activation Timing
This module is activated if launch_run_out
becomes true
Inner-workings / Algorithms
Flow chart
@startuml
title modifyPathVelocity
start
partition "Preprocess path" {
:Calculate the expected target velocity for ego vehicle;
:Extend path;
:Trim path from ego position;
}
partition "Preprocess obstacles" {
:Create data of abstracted dynamic obstacles;
:Exclude obstacles outside of partition lanelet;
}
partition "Collision_detection" {
:Detect collision with dynamic obstacles;
}
partition "Insert velocity" {
:Insert velocity to decelerate for obstacles;
:Limit velocity with specified jerk and acc limit;
}
stop
@enduml
Preprocess path
Calculate the expected target velocity for ego vehicle
Calculate the expected target velocity for the ego vehicle path to calculate time to collision with obstacles more precisely. The expected target velocity is calculated with motion velocity smoother module by using current velocity, current acceleration and velocity limits directed by the map and external API.
Extend the path
The path is extended by the length of base link to front to consider obstacles after the goal.
Trim path from ego position
The path is trimmed from ego position to a certain distance to reduce calculation time.
Trimmed distance is specified by parameter of detection_distance
.
Preprocess obstacles
Create data of abstracted dynamic obstacle
This module can handle multiple types of obstacles by creating abstracted dynamic obstacle data layer. Currently we have 3 types of detection method (Object, ObjectWithoutPath, Points) to create abstracted obstacle data.
Abstracted dynamic obstacle
Abstracted obstacle data has following information.
Name | Type | Description |
---|---|---|
pose | geometry_msgs::msg::Pose |
pose of the obstacle |
classifications | std::vector<autoware_auto_perception_msgs::msg::ObjectClassification> |
classifications with probability |
shape | autoware_auto_perception_msgs::msg::Shape |
shape of the obstacle |
predicted_paths | std::vector<DynamicObstacle::PredictedPath> |
predicted paths with confidence. this data doesn’t have time step because we use minimum and maximum velocity instead. |
min_velocity_mps | float |
minimum velocity of the obstacle. specified by parameter of dynamic_obstacle.min_vel_kmph
|
max_velocity_mps | float |
maximum velocity of the obstacle. specified by parameter of dynamic_obstacle.max_vel_kmph
|
Enter the maximum/minimum velocity of the object as a parameter, adding enough margin to the expected velocity. This parameter is used to create polygons for collision detection.
Future work: Determine the maximum/minimum velocity from the estimated velocity with covariance of the object
3 types of detection method
We have 3 types of detection method to meet different safety and availability requirements. The characteristics of them are shown in the table below.
Method of Object
has high availability (less false positive) because it detects only objects whose predicted path is on the lane. However, sometimes it is not safe because perception may fail to detect obstacles or generate incorrect predicted paths.
On the other hand, method of Points
has high safety (less false negative) because it uses pointcloud as input. Since points don’t have a predicted path, the path that moves in the direction normal to the path of ego vehicle is considered to be the predicted path of abstracted dynamic obstacle data. However, without proper adjustment of filter of points, it may detect a lot of points and it will result in very low availability.
Method of ObjectWithoutPath
has the characteristics of an intermediate of Object
and Points
.
Method | Description |
---|---|
Object | use an object with the predicted path for collision detection. |
ObjectWithoutPath | use an object but not use the predicted path for collision detection. replace the path assuming that an object jumps out to the lane at specified velocity. |
Points | use filtered points for collision detection. the path is created assuming that points jump out to the lane. points are regarded as an small circular shaped obstacle. |
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Name |
---|
eigen |
libboost-dev |
Dependant Packages
Name | Deps |
---|---|
behavior_velocity_planner |
Launch files
Messages
Services
Plugins
Recent questions tagged behavior_velocity_run_out_module at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 0.1.0 |
License | Apache License 2.0 |
Build type | AMENT_CMAKE |
Use | RECOMMENDED |
Repository Summary
Description | |
Checkout URI | https://github.com/ieiauto/autodrrt.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-05-30 |
Dev Status | UNKNOWN |
Released | UNRELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Tomohito Ando
- Makoto Kurihara
- Tomoya Kimura
- Shumpei Wakabayashi
- Takayuki Murooka
Authors
- Tomohito Ando
Run Out
Role
run_out
is the module that decelerates and stops for dynamic obstacles such as pedestrians and bicycles.
Activation Timing
This module is activated if launch_run_out
becomes true
Inner-workings / Algorithms
Flow chart
@startuml
title modifyPathVelocity
start
partition "Preprocess path" {
:Calculate the expected target velocity for ego vehicle;
:Extend path;
:Trim path from ego position;
}
partition "Preprocess obstacles" {
:Create data of abstracted dynamic obstacles;
:Exclude obstacles outside of partition lanelet;
}
partition "Collision_detection" {
:Detect collision with dynamic obstacles;
}
partition "Insert velocity" {
:Insert velocity to decelerate for obstacles;
:Limit velocity with specified jerk and acc limit;
}
stop
@enduml
Preprocess path
Calculate the expected target velocity for ego vehicle
Calculate the expected target velocity for the ego vehicle path to calculate time to collision with obstacles more precisely. The expected target velocity is calculated with motion velocity smoother module by using current velocity, current acceleration and velocity limits directed by the map and external API.
Extend the path
The path is extended by the length of base link to front to consider obstacles after the goal.
Trim path from ego position
The path is trimmed from ego position to a certain distance to reduce calculation time.
Trimmed distance is specified by parameter of detection_distance
.
Preprocess obstacles
Create data of abstracted dynamic obstacle
This module can handle multiple types of obstacles by creating abstracted dynamic obstacle data layer. Currently we have 3 types of detection method (Object, ObjectWithoutPath, Points) to create abstracted obstacle data.
Abstracted dynamic obstacle
Abstracted obstacle data has following information.
Name | Type | Description |
---|---|---|
pose | geometry_msgs::msg::Pose |
pose of the obstacle |
classifications | std::vector<autoware_auto_perception_msgs::msg::ObjectClassification> |
classifications with probability |
shape | autoware_auto_perception_msgs::msg::Shape |
shape of the obstacle |
predicted_paths | std::vector<DynamicObstacle::PredictedPath> |
predicted paths with confidence. this data doesn’t have time step because we use minimum and maximum velocity instead. |
min_velocity_mps | float |
minimum velocity of the obstacle. specified by parameter of dynamic_obstacle.min_vel_kmph
|
max_velocity_mps | float |
maximum velocity of the obstacle. specified by parameter of dynamic_obstacle.max_vel_kmph
|
Enter the maximum/minimum velocity of the object as a parameter, adding enough margin to the expected velocity. This parameter is used to create polygons for collision detection.
Future work: Determine the maximum/minimum velocity from the estimated velocity with covariance of the object
3 types of detection method
We have 3 types of detection method to meet different safety and availability requirements. The characteristics of them are shown in the table below.
Method of Object
has high availability (less false positive) because it detects only objects whose predicted path is on the lane. However, sometimes it is not safe because perception may fail to detect obstacles or generate incorrect predicted paths.
On the other hand, method of Points
has high safety (less false negative) because it uses pointcloud as input. Since points don’t have a predicted path, the path that moves in the direction normal to the path of ego vehicle is considered to be the predicted path of abstracted dynamic obstacle data. However, without proper adjustment of filter of points, it may detect a lot of points and it will result in very low availability.
Method of ObjectWithoutPath
has the characteristics of an intermediate of Object
and Points
.
Method | Description |
---|---|
Object | use an object with the predicted path for collision detection. |
ObjectWithoutPath | use an object but not use the predicted path for collision detection. replace the path assuming that an object jumps out to the lane at specified velocity. |
Points | use filtered points for collision detection. the path is created assuming that points jump out to the lane. points are regarded as an small circular shaped obstacle. |
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Name |
---|
eigen |
libboost-dev |
Dependant Packages
Name | Deps |
---|---|
behavior_velocity_planner |
Launch files
Messages
Services
Plugins
Recent questions tagged behavior_velocity_run_out_module at Robotics Stack Exchange
Package Summary
Tags | No category tags. |
Version | 0.1.0 |
License | Apache License 2.0 |
Build type | AMENT_CMAKE |
Use | RECOMMENDED |
Repository Summary
Description | |
Checkout URI | https://github.com/ieiauto/autodrrt.git |
VCS Type | git |
VCS Version | main |
Last Updated | 2025-05-30 |
Dev Status | UNKNOWN |
Released | UNRELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Tomohito Ando
- Makoto Kurihara
- Tomoya Kimura
- Shumpei Wakabayashi
- Takayuki Murooka
Authors
- Tomohito Ando
Run Out
Role
run_out
is the module that decelerates and stops for dynamic obstacles such as pedestrians and bicycles.
Activation Timing
This module is activated if launch_run_out
becomes true
Inner-workings / Algorithms
Flow chart
@startuml
title modifyPathVelocity
start
partition "Preprocess path" {
:Calculate the expected target velocity for ego vehicle;
:Extend path;
:Trim path from ego position;
}
partition "Preprocess obstacles" {
:Create data of abstracted dynamic obstacles;
:Exclude obstacles outside of partition lanelet;
}
partition "Collision_detection" {
:Detect collision with dynamic obstacles;
}
partition "Insert velocity" {
:Insert velocity to decelerate for obstacles;
:Limit velocity with specified jerk and acc limit;
}
stop
@enduml
Preprocess path
Calculate the expected target velocity for ego vehicle
Calculate the expected target velocity for the ego vehicle path to calculate time to collision with obstacles more precisely. The expected target velocity is calculated with motion velocity smoother module by using current velocity, current acceleration and velocity limits directed by the map and external API.
Extend the path
The path is extended by the length of base link to front to consider obstacles after the goal.
Trim path from ego position
The path is trimmed from ego position to a certain distance to reduce calculation time.
Trimmed distance is specified by parameter of detection_distance
.
Preprocess obstacles
Create data of abstracted dynamic obstacle
This module can handle multiple types of obstacles by creating abstracted dynamic obstacle data layer. Currently we have 3 types of detection method (Object, ObjectWithoutPath, Points) to create abstracted obstacle data.
Abstracted dynamic obstacle
Abstracted obstacle data has following information.
Name | Type | Description |
---|---|---|
pose | geometry_msgs::msg::Pose |
pose of the obstacle |
classifications | std::vector<autoware_auto_perception_msgs::msg::ObjectClassification> |
classifications with probability |
shape | autoware_auto_perception_msgs::msg::Shape |
shape of the obstacle |
predicted_paths | std::vector<DynamicObstacle::PredictedPath> |
predicted paths with confidence. this data doesn’t have time step because we use minimum and maximum velocity instead. |
min_velocity_mps | float |
minimum velocity of the obstacle. specified by parameter of dynamic_obstacle.min_vel_kmph
|
max_velocity_mps | float |
maximum velocity of the obstacle. specified by parameter of dynamic_obstacle.max_vel_kmph
|
Enter the maximum/minimum velocity of the object as a parameter, adding enough margin to the expected velocity. This parameter is used to create polygons for collision detection.
Future work: Determine the maximum/minimum velocity from the estimated velocity with covariance of the object
3 types of detection method
We have 3 types of detection method to meet different safety and availability requirements. The characteristics of them are shown in the table below.
Method of Object
has high availability (less false positive) because it detects only objects whose predicted path is on the lane. However, sometimes it is not safe because perception may fail to detect obstacles or generate incorrect predicted paths.
On the other hand, method of Points
has high safety (less false negative) because it uses pointcloud as input. Since points don’t have a predicted path, the path that moves in the direction normal to the path of ego vehicle is considered to be the predicted path of abstracted dynamic obstacle data. However, without proper adjustment of filter of points, it may detect a lot of points and it will result in very low availability.
Method of ObjectWithoutPath
has the characteristics of an intermediate of Object
and Points
.
Method | Description |
---|---|
Object | use an object with the predicted path for collision detection. |
ObjectWithoutPath | use an object but not use the predicted path for collision detection. replace the path assuming that an object jumps out to the lane at specified velocity. |
Points | use filtered points for collision detection. the path is created assuming that points jump out to the lane. points are regarded as an small circular shaped obstacle. |
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Name |
---|
eigen |
libboost-dev |
Dependant Packages
Name | Deps |
---|---|
behavior_velocity_planner |