|
mrpt_tps_astar_planner package from mrpt_navigation repomrpt_map_server mrpt_msgs_bridge mrpt_nav_interfaces mrpt_navigation mrpt_pf_localization mrpt_pointcloud_pipeline mrpt_reactivenav2d mrpt_tps_astar_planner mrpt_trajectory_follower mrpt_tutorials |
ROS Distro
|
Package Summary
| Version | 2.9.0 |
| License | BSD |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/mrpt-ros-pkg/mrpt_navigation.git |
| VCS Type | git |
| VCS Version | ros2 |
| Last Updated | 2026-11-14 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Jose-Luis Blanco-Claraco
- Shravan S Rai
Authors
- Shravan_S_Rai
- Jose-Luis Blanco-Claraco
mrpt_tps_astar_planner
Overview
This package provides a ROS 2 node that uses the PTG-based A* planner from
mrpt_path_planning to compute collision-free waypoint sequences for a
non-holonomic robot, respecting its real shape, orientation, and kinematic
constraints.
Planning is performed on a SE(2) lattice using Parameterized Trajectory
Generator (PTG) families that encode the robot’s motion primitives. The result
is published as a mrpt_msgs/WaypointSequence (and a nav_msgs/Path for
visualization) and/or returned as the response of a ROS 2 service call.
The node supports concurrent service requests: each executor thread owns a lazily-initialized planner instance, so multiple clients can request plans simultaneously without blocking each other.
How to cite
If you use this planner in your work, please cite the paper that describes it (arXiv:2611.09210):
@misc{blanco2026tpsastar,
title = {{TPS-A*}: Path Planning for Any-Shape Vehicles with Certified Collision Checking in Trajectory Parameter Space},
author = {Blanco-Claraco, Jos{\'e} Luis and Rai, Shravan S. and Ca{\~n}adas-Ar{\'a}nega, Fernando and Torres-Moreno, Jos{\'e} Luis and Moreno-{\'U}beda, Jos{\'e} Carlos},
year = {2026},
eprint = {2611.09210},
archivePrefix = {arXiv},
primaryClass = {cs.RO},
url = {https://arxiv.org/abs/2611.09210}
}
Configuration
Key configuration files passed as ROS 2 parameters:
| Parameter | Description |
|---|---|
ptg_ini |
INI file describing PTG families (robot kinematics) |
planner_parameters |
YAML file with A* algorithm parameters |
global_costmap_parameters |
YAML file for costmap obstacle-inflation parameters |
prefer_waypoints_parameters |
YAML file for waypoint-preference cost weights |
Demos
See the path-planner-sandbox/ subdirectory for standalone test scripts and
sample maps.
Node: mrpt_tps_astar_planner_node
Working rationale
- Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
- On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
- The planned path is interpolated at a fixed time step and converted to a
WaypointSequence.
At startup the PTG lookup tables are built in the background, which can take
tens of seconds. The planning services and the navigate_goal action are only
offered once they are ready, so clients see them as unavailable (and can wait
for them) instead of getting a failed plan. Topic goals received meanwhile are
rejected with a warning in the log (PTGs initialized marks when the node is
ready).
The A* implementation is an anytime algorithm: it improves the solution while
time allows, then returns the best found. An optional refinement pass
(astar_skip_refine: false) further smooths the result.
Navigation goals: anytime and continuous planning
Goals from <topic_goal_sub> (e.g. clicked in RViz/Foxglove) or the
~/navigate_goal action are handled by a goal manager running in a background
thread, so the robot starts moving soon and reacts to obstacles in advance:
-
Anytime: if the search has not reached the goal after
anytime_first_path_time, the best partial path so far (the tree node closest to the goal, if it gets at leastanytime_min_progresscloser) is published, and the robot starts following it while the search goes on. -
Continuous: every
replan_period, the search root moves to a nodestitch_lookahead_timeahead of the robot along its path. The path up to it is committed (it never changes), and the search grows the same tree from there with the latest obstacles until it reaches the goal. Path updates keep the committed part, so the follower switches to them without slowing down. - Each cycle, the rest of the path is checked against the current obstacles
(robot footprint). If it is blocked, the path is cut short before the
obstacle (the follower stops there if needed) and a new search starts from
scratch: from the end of the committed part, or from the robot if the
obstacle is before it (cutting the path there, so the robot does not drive
past it meanwhile). Follower failures (
Blocked,OffPathExceeded,MissedGoal, or stayingBlockedfor 5 s) restart it from the robot pose. A search that ends with no path to follow (no motion possible from the robot pose, or no way with the current obstacles, maybe transient) is
File truncated at 100 lines see the full file
Changelog for package mrpt_tps_astar_planner_node
2.9.0 (2026-11-14)
- New NavigateWaypoints action (~/navigate_waypoints): a waypoint sequence handled as a single goal, switching to the next waypoint shortly before reaching the current one, so the robot does not stop on the way.
- NavigateWaypoints wait_if_blocked: stop and wait at obstacles blocking the path (or at a waypoint in collision) instead of detouring.
- Ignore robot speed estimates above the PTG max speed (e.g. localization jumps).
- Fix: an empty obstacle source no longer terminates the planner node.
- Relative default follower status topics (resolved in the planner namespace), and warn once if no follower status arrives.
- README: how to cite the TPS-A* planner paper.
- Contributors: Jose Luis Blanco-Claraco
2.8.0 (2026-11-01)
2.7.0 (2026-10-29)
- Adapt to mrpt_path_planning 2.x (NavEngine removed); nodes are now composable.
- Anytime and continuous planning of navigation goals with a goal manager: re-rooting, path validation against new obstacles, replanning on follower failures or blocked paths until no progress (no_progress_timeout), memory of blocking obstacles, starting from the predicted pose of moving robots.
- Navigation status stream, HUD markers and richer action feedback/results.
- PTG lookup tables built in background; services and action offered once ready, topic goals queued meanwhile.
- New parameters: turning_cost_factor, max_computation_time, anytime_max_partial_length, reverse motion cost; plan requests can ignore obstacles inside polygons.
- Reject goals whose footprint hits an obstacle; transform PoseStamped goals into the map frame.
- Costmap publishing: from the goal manager, latched for late subscribers, skipped without subscribers.
- Differential-drive demos with rotations in place (DiffDrive_Spin PTG); robot footprint topic.
- Contributors: Jose Luis Blanco-Claraco
2.6.1 (2026-10-02)
2.6.0 (2026-10-01)
- Merge pull request #176 from mrpt-ros-pkg/docs/tps-astar-planner-params
- Enable backward motion in the default PTG set
- mrpt_tps_astar_planner: document the weighted-A* and Reeds-Shepp planner options
- Merge pull request #175 from mrpt-ros-pkg/mrpt3
- Merge ros2 into mrpt3
- Declare missing MRPT 3.x package.xml dependencies
- mrpt_tps_astar_planner: link the split-off mrpt_path_planning_viz lib
- mrpt_tps_astar_planner: link against the actual mpp::mrpt_path_planning target
- Merge pull request #174 from mrpt-ros-pkg/fix/astar-planner-mpp-compat
- fix(tps_astar_planner): properly SFINAE-guard windowTitle and ptgStepIndex
- fix: sfinae to set window title on mrpt_path_planning newer versions
- tps_astar_planner: fix clang-format violation blocking CI
- tps_astar_planner_node: densify solution path before GUI render, titled window
- update to use new mpp lib structure
- Merge pull request #169 from mrpt-ros-pkg/feat/astar-footprint-aware-costmap
- feat(tps_astar_planner): footprint-aware clearance costmap (back-compatible)
- Merge pull request #168 from mrpt-ros-pkg/fix/tps-astar-concurrent-planning-race
- fix(tps_astar_planner): serialize planning to avoid concurrent PTG corruption
- Merge pull request #163 from mrpt-ros-pkg/feature/ccache-support
- build: enable ccache in all packages when available
- Port to mrpt3: fix yaml API, mrpt::opengl→viz, CImage, asCvMatRef
- Port to MRPT 3.x: rename packages and targets
- Contributors: Jose Luis Blanco-Claraco
2.5.0 (2026-05-11)
- Merge pull request #161 from mrpt-ros-pkg/fix-threads Fix threads
- fix: safer multithreading access
- Merge pull request #159
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| mrpt_navigation |
Launch files
Messages
Services
Plugins
Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange
|
mrpt_tps_astar_planner package from mrpt_navigation repomrpt_map_server mrpt_msgs_bridge mrpt_nav_interfaces mrpt_navigation mrpt_pf_localization mrpt_pointcloud_pipeline mrpt_reactivenav2d mrpt_tps_astar_planner mrpt_trajectory_follower mrpt_tutorials |
ROS Distro
|
Package Summary
| Version | 2.9.0 |
| License | BSD |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/mrpt-ros-pkg/mrpt_navigation.git |
| VCS Type | git |
| VCS Version | ros2 |
| Last Updated | 2026-11-14 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Jose-Luis Blanco-Claraco
- Shravan S Rai
Authors
- Shravan_S_Rai
- Jose-Luis Blanco-Claraco
mrpt_tps_astar_planner
Overview
This package provides a ROS 2 node that uses the PTG-based A* planner from
mrpt_path_planning to compute collision-free waypoint sequences for a
non-holonomic robot, respecting its real shape, orientation, and kinematic
constraints.
Planning is performed on a SE(2) lattice using Parameterized Trajectory
Generator (PTG) families that encode the robot’s motion primitives. The result
is published as a mrpt_msgs/WaypointSequence (and a nav_msgs/Path for
visualization) and/or returned as the response of a ROS 2 service call.
The node supports concurrent service requests: each executor thread owns a lazily-initialized planner instance, so multiple clients can request plans simultaneously without blocking each other.
How to cite
If you use this planner in your work, please cite the paper that describes it (arXiv:2611.09210):
@misc{blanco2026tpsastar,
title = {{TPS-A*}: Path Planning for Any-Shape Vehicles with Certified Collision Checking in Trajectory Parameter Space},
author = {Blanco-Claraco, Jos{\'e} Luis and Rai, Shravan S. and Ca{\~n}adas-Ar{\'a}nega, Fernando and Torres-Moreno, Jos{\'e} Luis and Moreno-{\'U}beda, Jos{\'e} Carlos},
year = {2026},
eprint = {2611.09210},
archivePrefix = {arXiv},
primaryClass = {cs.RO},
url = {https://arxiv.org/abs/2611.09210}
}
Configuration
Key configuration files passed as ROS 2 parameters:
| Parameter | Description |
|---|---|
ptg_ini |
INI file describing PTG families (robot kinematics) |
planner_parameters |
YAML file with A* algorithm parameters |
global_costmap_parameters |
YAML file for costmap obstacle-inflation parameters |
prefer_waypoints_parameters |
YAML file for waypoint-preference cost weights |
Demos
See the path-planner-sandbox/ subdirectory for standalone test scripts and
sample maps.
Node: mrpt_tps_astar_planner_node
Working rationale
- Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
- On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
- The planned path is interpolated at a fixed time step and converted to a
WaypointSequence.
At startup the PTG lookup tables are built in the background, which can take
tens of seconds. The planning services and the navigate_goal action are only
offered once they are ready, so clients see them as unavailable (and can wait
for them) instead of getting a failed plan. Topic goals received meanwhile are
rejected with a warning in the log (PTGs initialized marks when the node is
ready).
The A* implementation is an anytime algorithm: it improves the solution while
time allows, then returns the best found. An optional refinement pass
(astar_skip_refine: false) further smooths the result.
Navigation goals: anytime and continuous planning
Goals from <topic_goal_sub> (e.g. clicked in RViz/Foxglove) or the
~/navigate_goal action are handled by a goal manager running in a background
thread, so the robot starts moving soon and reacts to obstacles in advance:
-
Anytime: if the search has not reached the goal after
anytime_first_path_time, the best partial path so far (the tree node closest to the goal, if it gets at leastanytime_min_progresscloser) is published, and the robot starts following it while the search goes on. -
Continuous: every
replan_period, the search root moves to a nodestitch_lookahead_timeahead of the robot along its path. The path up to it is committed (it never changes), and the search grows the same tree from there with the latest obstacles until it reaches the goal. Path updates keep the committed part, so the follower switches to them without slowing down. - Each cycle, the rest of the path is checked against the current obstacles
(robot footprint). If it is blocked, the path is cut short before the
obstacle (the follower stops there if needed) and a new search starts from
scratch: from the end of the committed part, or from the robot if the
obstacle is before it (cutting the path there, so the robot does not drive
past it meanwhile). Follower failures (
Blocked,OffPathExceeded,MissedGoal, or stayingBlockedfor 5 s) restart it from the robot pose. A search that ends with no path to follow (no motion possible from the robot pose, or no way with the current obstacles, maybe transient) is
File truncated at 100 lines see the full file
Changelog for package mrpt_tps_astar_planner_node
2.9.0 (2026-11-14)
- New NavigateWaypoints action (~/navigate_waypoints): a waypoint sequence handled as a single goal, switching to the next waypoint shortly before reaching the current one, so the robot does not stop on the way.
- NavigateWaypoints wait_if_blocked: stop and wait at obstacles blocking the path (or at a waypoint in collision) instead of detouring.
- Ignore robot speed estimates above the PTG max speed (e.g. localization jumps).
- Fix: an empty obstacle source no longer terminates the planner node.
- Relative default follower status topics (resolved in the planner namespace), and warn once if no follower status arrives.
- README: how to cite the TPS-A* planner paper.
- Contributors: Jose Luis Blanco-Claraco
2.8.0 (2026-11-01)
2.7.0 (2026-10-29)
- Adapt to mrpt_path_planning 2.x (NavEngine removed); nodes are now composable.
- Anytime and continuous planning of navigation goals with a goal manager: re-rooting, path validation against new obstacles, replanning on follower failures or blocked paths until no progress (no_progress_timeout), memory of blocking obstacles, starting from the predicted pose of moving robots.
- Navigation status stream, HUD markers and richer action feedback/results.
- PTG lookup tables built in background; services and action offered once ready, topic goals queued meanwhile.
- New parameters: turning_cost_factor, max_computation_time, anytime_max_partial_length, reverse motion cost; plan requests can ignore obstacles inside polygons.
- Reject goals whose footprint hits an obstacle; transform PoseStamped goals into the map frame.
- Costmap publishing: from the goal manager, latched for late subscribers, skipped without subscribers.
- Differential-drive demos with rotations in place (DiffDrive_Spin PTG); robot footprint topic.
- Contributors: Jose Luis Blanco-Claraco
2.6.1 (2026-10-02)
2.6.0 (2026-10-01)
- Merge pull request #176 from mrpt-ros-pkg/docs/tps-astar-planner-params
- Enable backward motion in the default PTG set
- mrpt_tps_astar_planner: document the weighted-A* and Reeds-Shepp planner options
- Merge pull request #175 from mrpt-ros-pkg/mrpt3
- Merge ros2 into mrpt3
- Declare missing MRPT 3.x package.xml dependencies
- mrpt_tps_astar_planner: link the split-off mrpt_path_planning_viz lib
- mrpt_tps_astar_planner: link against the actual mpp::mrpt_path_planning target
- Merge pull request #174 from mrpt-ros-pkg/fix/astar-planner-mpp-compat
- fix(tps_astar_planner): properly SFINAE-guard windowTitle and ptgStepIndex
- fix: sfinae to set window title on mrpt_path_planning newer versions
- tps_astar_planner: fix clang-format violation blocking CI
- tps_astar_planner_node: densify solution path before GUI render, titled window
- update to use new mpp lib structure
- Merge pull request #169 from mrpt-ros-pkg/feat/astar-footprint-aware-costmap
- feat(tps_astar_planner): footprint-aware clearance costmap (back-compatible)
- Merge pull request #168 from mrpt-ros-pkg/fix/tps-astar-concurrent-planning-race
- fix(tps_astar_planner): serialize planning to avoid concurrent PTG corruption
- Merge pull request #163 from mrpt-ros-pkg/feature/ccache-support
- build: enable ccache in all packages when available
- Port to mrpt3: fix yaml API, mrpt::opengl→viz, CImage, asCvMatRef
- Port to MRPT 3.x: rename packages and targets
- Contributors: Jose Luis Blanco-Claraco
2.5.0 (2026-05-11)
- Merge pull request #161 from mrpt-ros-pkg/fix-threads Fix threads
- fix: safer multithreading access
- Merge pull request #159
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| mrpt_navigation |
Launch files
Messages
Services
Plugins
Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange
|
mrpt_tps_astar_planner package from mrpt_navigation repomrpt_map_server mrpt_msgs_bridge mrpt_nav_interfaces mrpt_navigation mrpt_pf_localization mrpt_pointcloud_pipeline mrpt_reactivenav2d mrpt_tps_astar_planner mrpt_trajectory_follower mrpt_tutorials |
ROS Distro
|
Package Summary
| Version | 2.9.0 |
| License | BSD |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/mrpt-ros-pkg/mrpt_navigation.git |
| VCS Type | git |
| VCS Version | ros2 |
| Last Updated | 2026-11-14 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Jose-Luis Blanco-Claraco
- Shravan S Rai
Authors
- Shravan_S_Rai
- Jose-Luis Blanco-Claraco
mrpt_tps_astar_planner
Overview
This package provides a ROS 2 node that uses the PTG-based A* planner from
mrpt_path_planning to compute collision-free waypoint sequences for a
non-holonomic robot, respecting its real shape, orientation, and kinematic
constraints.
Planning is performed on a SE(2) lattice using Parameterized Trajectory
Generator (PTG) families that encode the robot’s motion primitives. The result
is published as a mrpt_msgs/WaypointSequence (and a nav_msgs/Path for
visualization) and/or returned as the response of a ROS 2 service call.
The node supports concurrent service requests: each executor thread owns a lazily-initialized planner instance, so multiple clients can request plans simultaneously without blocking each other.
How to cite
If you use this planner in your work, please cite the paper that describes it (arXiv:2611.09210):
@misc{blanco2026tpsastar,
title = {{TPS-A*}: Path Planning for Any-Shape Vehicles with Certified Collision Checking in Trajectory Parameter Space},
author = {Blanco-Claraco, Jos{\'e} Luis and Rai, Shravan S. and Ca{\~n}adas-Ar{\'a}nega, Fernando and Torres-Moreno, Jos{\'e} Luis and Moreno-{\'U}beda, Jos{\'e} Carlos},
year = {2026},
eprint = {2611.09210},
archivePrefix = {arXiv},
primaryClass = {cs.RO},
url = {https://arxiv.org/abs/2611.09210}
}
Configuration
Key configuration files passed as ROS 2 parameters:
| Parameter | Description |
|---|---|
ptg_ini |
INI file describing PTG families (robot kinematics) |
planner_parameters |
YAML file with A* algorithm parameters |
global_costmap_parameters |
YAML file for costmap obstacle-inflation parameters |
prefer_waypoints_parameters |
YAML file for waypoint-preference cost weights |
Demos
See the path-planner-sandbox/ subdirectory for standalone test scripts and
sample maps.
Node: mrpt_tps_astar_planner_node
Working rationale
- Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
- On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
- The planned path is interpolated at a fixed time step and converted to a
WaypointSequence.
At startup the PTG lookup tables are built in the background, which can take
tens of seconds. The planning services and the navigate_goal action are only
offered once they are ready, so clients see them as unavailable (and can wait
for them) instead of getting a failed plan. Topic goals received meanwhile are
rejected with a warning in the log (PTGs initialized marks when the node is
ready).
The A* implementation is an anytime algorithm: it improves the solution while
time allows, then returns the best found. An optional refinement pass
(astar_skip_refine: false) further smooths the result.
Navigation goals: anytime and continuous planning
Goals from <topic_goal_sub> (e.g. clicked in RViz/Foxglove) or the
~/navigate_goal action are handled by a goal manager running in a background
thread, so the robot starts moving soon and reacts to obstacles in advance:
-
Anytime: if the search has not reached the goal after
anytime_first_path_time, the best partial path so far (the tree node closest to the goal, if it gets at leastanytime_min_progresscloser) is published, and the robot starts following it while the search goes on. -
Continuous: every
replan_period, the search root moves to a nodestitch_lookahead_timeahead of the robot along its path. The path up to it is committed (it never changes), and the search grows the same tree from there with the latest obstacles until it reaches the goal. Path updates keep the committed part, so the follower switches to them without slowing down. - Each cycle, the rest of the path is checked against the current obstacles
(robot footprint). If it is blocked, the path is cut short before the
obstacle (the follower stops there if needed) and a new search starts from
scratch: from the end of the committed part, or from the robot if the
obstacle is before it (cutting the path there, so the robot does not drive
past it meanwhile). Follower failures (
Blocked,OffPathExceeded,MissedGoal, or stayingBlockedfor 5 s) restart it from the robot pose. A search that ends with no path to follow (no motion possible from the robot pose, or no way with the current obstacles, maybe transient) is
File truncated at 100 lines see the full file
Changelog for package mrpt_tps_astar_planner_node
2.9.0 (2026-11-14)
- New NavigateWaypoints action (~/navigate_waypoints): a waypoint sequence handled as a single goal, switching to the next waypoint shortly before reaching the current one, so the robot does not stop on the way.
- NavigateWaypoints wait_if_blocked: stop and wait at obstacles blocking the path (or at a waypoint in collision) instead of detouring.
- Ignore robot speed estimates above the PTG max speed (e.g. localization jumps).
- Fix: an empty obstacle source no longer terminates the planner node.
- Relative default follower status topics (resolved in the planner namespace), and warn once if no follower status arrives.
- README: how to cite the TPS-A* planner paper.
- Contributors: Jose Luis Blanco-Claraco
2.8.0 (2026-11-01)
2.7.0 (2026-10-29)
- Adapt to mrpt_path_planning 2.x (NavEngine removed); nodes are now composable.
- Anytime and continuous planning of navigation goals with a goal manager: re-rooting, path validation against new obstacles, replanning on follower failures or blocked paths until no progress (no_progress_timeout), memory of blocking obstacles, starting from the predicted pose of moving robots.
- Navigation status stream, HUD markers and richer action feedback/results.
- PTG lookup tables built in background; services and action offered once ready, topic goals queued meanwhile.
- New parameters: turning_cost_factor, max_computation_time, anytime_max_partial_length, reverse motion cost; plan requests can ignore obstacles inside polygons.
- Reject goals whose footprint hits an obstacle; transform PoseStamped goals into the map frame.
- Costmap publishing: from the goal manager, latched for late subscribers, skipped without subscribers.
- Differential-drive demos with rotations in place (DiffDrive_Spin PTG); robot footprint topic.
- Contributors: Jose Luis Blanco-Claraco
2.6.1 (2026-10-02)
2.6.0 (2026-10-01)
- Merge pull request #176 from mrpt-ros-pkg/docs/tps-astar-planner-params
- Enable backward motion in the default PTG set
- mrpt_tps_astar_planner: document the weighted-A* and Reeds-Shepp planner options
- Merge pull request #175 from mrpt-ros-pkg/mrpt3
- Merge ros2 into mrpt3
- Declare missing MRPT 3.x package.xml dependencies
- mrpt_tps_astar_planner: link the split-off mrpt_path_planning_viz lib
- mrpt_tps_astar_planner: link against the actual mpp::mrpt_path_planning target
- Merge pull request #174 from mrpt-ros-pkg/fix/astar-planner-mpp-compat
- fix(tps_astar_planner): properly SFINAE-guard windowTitle and ptgStepIndex
- fix: sfinae to set window title on mrpt_path_planning newer versions
- tps_astar_planner: fix clang-format violation blocking CI
- tps_astar_planner_node: densify solution path before GUI render, titled window
- update to use new mpp lib structure
- Merge pull request #169 from mrpt-ros-pkg/feat/astar-footprint-aware-costmap
- feat(tps_astar_planner): footprint-aware clearance costmap (back-compatible)
- Merge pull request #168 from mrpt-ros-pkg/fix/tps-astar-concurrent-planning-race
- fix(tps_astar_planner): serialize planning to avoid concurrent PTG corruption
- Merge pull request #163 from mrpt-ros-pkg/feature/ccache-support
- build: enable ccache in all packages when available
- Port to mrpt3: fix yaml API, mrpt::opengl→viz, CImage, asCvMatRef
- Port to MRPT 3.x: rename packages and targets
- Contributors: Jose Luis Blanco-Claraco
2.5.0 (2026-05-11)
- Merge pull request #161 from mrpt-ros-pkg/fix-threads Fix threads
- fix: safer multithreading access
- Merge pull request #159
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| mrpt_navigation |
Launch files
Messages
Services
Plugins
Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange
|
mrpt_tps_astar_planner package from mrpt_navigation repomrpt_map_server mrpt_msgs_bridge mrpt_nav_interfaces mrpt_navigation mrpt_pf_localization mrpt_pointcloud_pipeline mrpt_reactivenav2d mrpt_tps_astar_planner mrpt_trajectory_follower mrpt_tutorials |
ROS Distro
|
Package Summary
| Version | 2.9.0 |
| License | BSD |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/mrpt-ros-pkg/mrpt_navigation.git |
| VCS Type | git |
| VCS Version | ros2 |
| Last Updated | 2026-11-14 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Jose-Luis Blanco-Claraco
- Shravan S Rai
Authors
- Shravan_S_Rai
- Jose-Luis Blanco-Claraco
mrpt_tps_astar_planner
Overview
This package provides a ROS 2 node that uses the PTG-based A* planner from
mrpt_path_planning to compute collision-free waypoint sequences for a
non-holonomic robot, respecting its real shape, orientation, and kinematic
constraints.
Planning is performed on a SE(2) lattice using Parameterized Trajectory
Generator (PTG) families that encode the robot’s motion primitives. The result
is published as a mrpt_msgs/WaypointSequence (and a nav_msgs/Path for
visualization) and/or returned as the response of a ROS 2 service call.
The node supports concurrent service requests: each executor thread owns a lazily-initialized planner instance, so multiple clients can request plans simultaneously without blocking each other.
How to cite
If you use this planner in your work, please cite the paper that describes it (arXiv:2611.09210):
@misc{blanco2026tpsastar,
title = {{TPS-A*}: Path Planning for Any-Shape Vehicles with Certified Collision Checking in Trajectory Parameter Space},
author = {Blanco-Claraco, Jos{\'e} Luis and Rai, Shravan S. and Ca{\~n}adas-Ar{\'a}nega, Fernando and Torres-Moreno, Jos{\'e} Luis and Moreno-{\'U}beda, Jos{\'e} Carlos},
year = {2026},
eprint = {2611.09210},
archivePrefix = {arXiv},
primaryClass = {cs.RO},
url = {https://arxiv.org/abs/2611.09210}
}
Configuration
Key configuration files passed as ROS 2 parameters:
| Parameter | Description |
|---|---|
ptg_ini |
INI file describing PTG families (robot kinematics) |
planner_parameters |
YAML file with A* algorithm parameters |
global_costmap_parameters |
YAML file for costmap obstacle-inflation parameters |
prefer_waypoints_parameters |
YAML file for waypoint-preference cost weights |
Demos
See the path-planner-sandbox/ subdirectory for standalone test scripts and
sample maps.
Node: mrpt_tps_astar_planner_node
Working rationale
- Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
- On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
- The planned path is interpolated at a fixed time step and converted to a
WaypointSequence.
At startup the PTG lookup tables are built in the background, which can take
tens of seconds. The planning services and the navigate_goal action are only
offered once they are ready, so clients see them as unavailable (and can wait
for them) instead of getting a failed plan. Topic goals received meanwhile are
rejected with a warning in the log (PTGs initialized marks when the node is
ready).
The A* implementation is an anytime algorithm: it improves the solution while
time allows, then returns the best found. An optional refinement pass
(astar_skip_refine: false) further smooths the result.
Navigation goals: anytime and continuous planning
Goals from <topic_goal_sub> (e.g. clicked in RViz/Foxglove) or the
~/navigate_goal action are handled by a goal manager running in a background
thread, so the robot starts moving soon and reacts to obstacles in advance:
-
Anytime: if the search has not reached the goal after
anytime_first_path_time, the best partial path so far (the tree node closest to the goal, if it gets at leastanytime_min_progresscloser) is published, and the robot starts following it while the search goes on. -
Continuous: every
replan_period, the search root moves to a nodestitch_lookahead_timeahead of the robot along its path. The path up to it is committed (it never changes), and the search grows the same tree from there with the latest obstacles until it reaches the goal. Path updates keep the committed part, so the follower switches to them without slowing down. - Each cycle, the rest of the path is checked against the current obstacles
(robot footprint). If it is blocked, the path is cut short before the
obstacle (the follower stops there if needed) and a new search starts from
scratch: from the end of the committed part, or from the robot if the
obstacle is before it (cutting the path there, so the robot does not drive
past it meanwhile). Follower failures (
Blocked,OffPathExceeded,MissedGoal, or stayingBlockedfor 5 s) restart it from the robot pose. A search that ends with no path to follow (no motion possible from the robot pose, or no way with the current obstacles, maybe transient) is
File truncated at 100 lines see the full file
Changelog for package mrpt_tps_astar_planner_node
2.9.0 (2026-11-14)
- New NavigateWaypoints action (~/navigate_waypoints): a waypoint sequence handled as a single goal, switching to the next waypoint shortly before reaching the current one, so the robot does not stop on the way.
- NavigateWaypoints wait_if_blocked: stop and wait at obstacles blocking the path (or at a waypoint in collision) instead of detouring.
- Ignore robot speed estimates above the PTG max speed (e.g. localization jumps).
- Fix: an empty obstacle source no longer terminates the planner node.
- Relative default follower status topics (resolved in the planner namespace), and warn once if no follower status arrives.
- README: how to cite the TPS-A* planner paper.
- Contributors: Jose Luis Blanco-Claraco
2.8.0 (2026-11-01)
2.7.0 (2026-10-29)
- Adapt to mrpt_path_planning 2.x (NavEngine removed); nodes are now composable.
- Anytime and continuous planning of navigation goals with a goal manager: re-rooting, path validation against new obstacles, replanning on follower failures or blocked paths until no progress (no_progress_timeout), memory of blocking obstacles, starting from the predicted pose of moving robots.
- Navigation status stream, HUD markers and richer action feedback/results.
- PTG lookup tables built in background; services and action offered once ready, topic goals queued meanwhile.
- New parameters: turning_cost_factor, max_computation_time, anytime_max_partial_length, reverse motion cost; plan requests can ignore obstacles inside polygons.
- Reject goals whose footprint hits an obstacle; transform PoseStamped goals into the map frame.
- Costmap publishing: from the goal manager, latched for late subscribers, skipped without subscribers.
- Differential-drive demos with rotations in place (DiffDrive_Spin PTG); robot footprint topic.
- Contributors: Jose Luis Blanco-Claraco
2.6.1 (2026-10-02)
2.6.0 (2026-10-01)
- Merge pull request #176 from mrpt-ros-pkg/docs/tps-astar-planner-params
- Enable backward motion in the default PTG set
- mrpt_tps_astar_planner: document the weighted-A* and Reeds-Shepp planner options
- Merge pull request #175 from mrpt-ros-pkg/mrpt3
- Merge ros2 into mrpt3
- Declare missing MRPT 3.x package.xml dependencies
- mrpt_tps_astar_planner: link the split-off mrpt_path_planning_viz lib
- mrpt_tps_astar_planner: link against the actual mpp::mrpt_path_planning target
- Merge pull request #174 from mrpt-ros-pkg/fix/astar-planner-mpp-compat
- fix(tps_astar_planner): properly SFINAE-guard windowTitle and ptgStepIndex
- fix: sfinae to set window title on mrpt_path_planning newer versions
- tps_astar_planner: fix clang-format violation blocking CI
- tps_astar_planner_node: densify solution path before GUI render, titled window
- update to use new mpp lib structure
- Merge pull request #169 from mrpt-ros-pkg/feat/astar-footprint-aware-costmap
- feat(tps_astar_planner): footprint-aware clearance costmap (back-compatible)
- Merge pull request #168 from mrpt-ros-pkg/fix/tps-astar-concurrent-planning-race
- fix(tps_astar_planner): serialize planning to avoid concurrent PTG corruption
- Merge pull request #163 from mrpt-ros-pkg/feature/ccache-support
- build: enable ccache in all packages when available
- Port to mrpt3: fix yaml API, mrpt::opengl→viz, CImage, asCvMatRef
- Port to MRPT 3.x: rename packages and targets
- Contributors: Jose Luis Blanco-Claraco
2.5.0 (2026-05-11)
- Merge pull request #161 from mrpt-ros-pkg/fix-threads Fix threads
- fix: safer multithreading access
- Merge pull request #159
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| mrpt_navigation |
Launch files
Messages
Services
Plugins
Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange
|
mrpt_tps_astar_planner package from mrpt_navigation repomrpt_map_server mrpt_msgs_bridge mrpt_nav_interfaces mrpt_navigation mrpt_pf_localization mrpt_pointcloud_pipeline mrpt_reactivenav2d mrpt_tps_astar_planner mrpt_trajectory_follower mrpt_tutorials |
ROS Distro
|
Package Summary
| Version | 2.9.0 |
| License | BSD |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/mrpt-ros-pkg/mrpt_navigation.git |
| VCS Type | git |
| VCS Version | ros2 |
| Last Updated | 2026-11-14 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Jose-Luis Blanco-Claraco
- Shravan S Rai
Authors
- Shravan_S_Rai
- Jose-Luis Blanco-Claraco
mrpt_tps_astar_planner
Overview
This package provides a ROS 2 node that uses the PTG-based A* planner from
mrpt_path_planning to compute collision-free waypoint sequences for a
non-holonomic robot, respecting its real shape, orientation, and kinematic
constraints.
Planning is performed on a SE(2) lattice using Parameterized Trajectory
Generator (PTG) families that encode the robot’s motion primitives. The result
is published as a mrpt_msgs/WaypointSequence (and a nav_msgs/Path for
visualization) and/or returned as the response of a ROS 2 service call.
The node supports concurrent service requests: each executor thread owns a lazily-initialized planner instance, so multiple clients can request plans simultaneously without blocking each other.
How to cite
If you use this planner in your work, please cite the paper that describes it (arXiv:2611.09210):
@misc{blanco2026tpsastar,
title = {{TPS-A*}: Path Planning for Any-Shape Vehicles with Certified Collision Checking in Trajectory Parameter Space},
author = {Blanco-Claraco, Jos{\'e} Luis and Rai, Shravan S. and Ca{\~n}adas-Ar{\'a}nega, Fernando and Torres-Moreno, Jos{\'e} Luis and Moreno-{\'U}beda, Jos{\'e} Carlos},
year = {2026},
eprint = {2611.09210},
archivePrefix = {arXiv},
primaryClass = {cs.RO},
url = {https://arxiv.org/abs/2611.09210}
}
Configuration
Key configuration files passed as ROS 2 parameters:
| Parameter | Description |
|---|---|
ptg_ini |
INI file describing PTG families (robot kinematics) |
planner_parameters |
YAML file with A* algorithm parameters |
global_costmap_parameters |
YAML file for costmap obstacle-inflation parameters |
prefer_waypoints_parameters |
YAML file for waypoint-preference cost weights |
Demos
See the path-planner-sandbox/ subdirectory for standalone test scripts and
sample maps.
Node: mrpt_tps_astar_planner_node
Working rationale
- Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
- On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
- The planned path is interpolated at a fixed time step and converted to a
WaypointSequence.
At startup the PTG lookup tables are built in the background, which can take
tens of seconds. The planning services and the navigate_goal action are only
offered once they are ready, so clients see them as unavailable (and can wait
for them) instead of getting a failed plan. Topic goals received meanwhile are
rejected with a warning in the log (PTGs initialized marks when the node is
ready).
The A* implementation is an anytime algorithm: it improves the solution while
time allows, then returns the best found. An optional refinement pass
(astar_skip_refine: false) further smooths the result.
Navigation goals: anytime and continuous planning
Goals from <topic_goal_sub> (e.g. clicked in RViz/Foxglove) or the
~/navigate_goal action are handled by a goal manager running in a background
thread, so the robot starts moving soon and reacts to obstacles in advance:
-
Anytime: if the search has not reached the goal after
anytime_first_path_time, the best partial path so far (the tree node closest to the goal, if it gets at leastanytime_min_progresscloser) is published, and the robot starts following it while the search goes on. -
Continuous: every
replan_period, the search root moves to a nodestitch_lookahead_timeahead of the robot along its path. The path up to it is committed (it never changes), and the search grows the same tree from there with the latest obstacles until it reaches the goal. Path updates keep the committed part, so the follower switches to them without slowing down. - Each cycle, the rest of the path is checked against the current obstacles
(robot footprint). If it is blocked, the path is cut short before the
obstacle (the follower stops there if needed) and a new search starts from
scratch: from the end of the committed part, or from the robot if the
obstacle is before it (cutting the path there, so the robot does not drive
past it meanwhile). Follower failures (
Blocked,OffPathExceeded,MissedGoal, or stayingBlockedfor 5 s) restart it from the robot pose. A search that ends with no path to follow (no motion possible from the robot pose, or no way with the current obstacles, maybe transient) is
File truncated at 100 lines see the full file
Changelog for package mrpt_tps_astar_planner_node
2.9.0 (2026-11-14)
- New NavigateWaypoints action (~/navigate_waypoints): a waypoint sequence handled as a single goal, switching to the next waypoint shortly before reaching the current one, so the robot does not stop on the way.
- NavigateWaypoints wait_if_blocked: stop and wait at obstacles blocking the path (or at a waypoint in collision) instead of detouring.
- Ignore robot speed estimates above the PTG max speed (e.g. localization jumps).
- Fix: an empty obstacle source no longer terminates the planner node.
- Relative default follower status topics (resolved in the planner namespace), and warn once if no follower status arrives.
- README: how to cite the TPS-A* planner paper.
- Contributors: Jose Luis Blanco-Claraco
2.8.0 (2026-11-01)
2.7.0 (2026-10-29)
- Adapt to mrpt_path_planning 2.x (NavEngine removed); nodes are now composable.
- Anytime and continuous planning of navigation goals with a goal manager: re-rooting, path validation against new obstacles, replanning on follower failures or blocked paths until no progress (no_progress_timeout), memory of blocking obstacles, starting from the predicted pose of moving robots.
- Navigation status stream, HUD markers and richer action feedback/results.
- PTG lookup tables built in background; services and action offered once ready, topic goals queued meanwhile.
- New parameters: turning_cost_factor, max_computation_time, anytime_max_partial_length, reverse motion cost; plan requests can ignore obstacles inside polygons.
- Reject goals whose footprint hits an obstacle; transform PoseStamped goals into the map frame.
- Costmap publishing: from the goal manager, latched for late subscribers, skipped without subscribers.
- Differential-drive demos with rotations in place (DiffDrive_Spin PTG); robot footprint topic.
- Contributors: Jose Luis Blanco-Claraco
2.6.1 (2026-10-02)
2.6.0 (2026-10-01)
- Merge pull request #176 from mrpt-ros-pkg/docs/tps-astar-planner-params
- Enable backward motion in the default PTG set
- mrpt_tps_astar_planner: document the weighted-A* and Reeds-Shepp planner options
- Merge pull request #175 from mrpt-ros-pkg/mrpt3
- Merge ros2 into mrpt3
- Declare missing MRPT 3.x package.xml dependencies
- mrpt_tps_astar_planner: link the split-off mrpt_path_planning_viz lib
- mrpt_tps_astar_planner: link against the actual mpp::mrpt_path_planning target
- Merge pull request #174 from mrpt-ros-pkg/fix/astar-planner-mpp-compat
- fix(tps_astar_planner): properly SFINAE-guard windowTitle and ptgStepIndex
- fix: sfinae to set window title on mrpt_path_planning newer versions
- tps_astar_planner: fix clang-format violation blocking CI
- tps_astar_planner_node: densify solution path before GUI render, titled window
- update to use new mpp lib structure
- Merge pull request #169 from mrpt-ros-pkg/feat/astar-footprint-aware-costmap
- feat(tps_astar_planner): footprint-aware clearance costmap (back-compatible)
- Merge pull request #168 from mrpt-ros-pkg/fix/tps-astar-concurrent-planning-race
- fix(tps_astar_planner): serialize planning to avoid concurrent PTG corruption
- Merge pull request #163 from mrpt-ros-pkg/feature/ccache-support
- build: enable ccache in all packages when available
- Port to mrpt3: fix yaml API, mrpt::opengl→viz, CImage, asCvMatRef
- Port to MRPT 3.x: rename packages and targets
- Contributors: Jose Luis Blanco-Claraco
2.5.0 (2026-05-11)
- Merge pull request #161 from mrpt-ros-pkg/fix-threads Fix threads
- fix: safer multithreading access
- Merge pull request #159
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| mrpt_navigation |
Launch files
Messages
Services
Plugins
Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange
|
mrpt_tps_astar_planner package from mrpt_navigation repomrpt_map_server mrpt_msgs_bridge mrpt_nav_interfaces mrpt_navigation mrpt_pf_localization mrpt_pointcloud_pipeline mrpt_reactivenav2d mrpt_tps_astar_planner mrpt_trajectory_follower mrpt_tutorials |
ROS Distro
|
Package Summary
| Version | 2.9.0 |
| License | BSD |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/mrpt-ros-pkg/mrpt_navigation.git |
| VCS Type | git |
| VCS Version | ros2 |
| Last Updated | 2026-11-14 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Jose-Luis Blanco-Claraco
- Shravan S Rai
Authors
- Shravan_S_Rai
- Jose-Luis Blanco-Claraco
mrpt_tps_astar_planner
Overview
This package provides a ROS 2 node that uses the PTG-based A* planner from
mrpt_path_planning to compute collision-free waypoint sequences for a
non-holonomic robot, respecting its real shape, orientation, and kinematic
constraints.
Planning is performed on a SE(2) lattice using Parameterized Trajectory
Generator (PTG) families that encode the robot’s motion primitives. The result
is published as a mrpt_msgs/WaypointSequence (and a nav_msgs/Path for
visualization) and/or returned as the response of a ROS 2 service call.
The node supports concurrent service requests: each executor thread owns a lazily-initialized planner instance, so multiple clients can request plans simultaneously without blocking each other.
How to cite
If you use this planner in your work, please cite the paper that describes it (arXiv:2611.09210):
@misc{blanco2026tpsastar,
title = {{TPS-A*}: Path Planning for Any-Shape Vehicles with Certified Collision Checking in Trajectory Parameter Space},
author = {Blanco-Claraco, Jos{\'e} Luis and Rai, Shravan S. and Ca{\~n}adas-Ar{\'a}nega, Fernando and Torres-Moreno, Jos{\'e} Luis and Moreno-{\'U}beda, Jos{\'e} Carlos},
year = {2026},
eprint = {2611.09210},
archivePrefix = {arXiv},
primaryClass = {cs.RO},
url = {https://arxiv.org/abs/2611.09210}
}
Configuration
Key configuration files passed as ROS 2 parameters:
| Parameter | Description |
|---|---|
ptg_ini |
INI file describing PTG families (robot kinematics) |
planner_parameters |
YAML file with A* algorithm parameters |
global_costmap_parameters |
YAML file for costmap obstacle-inflation parameters |
prefer_waypoints_parameters |
YAML file for waypoint-preference cost weights |
Demos
See the path-planner-sandbox/ subdirectory for standalone test scripts and
sample maps.
Node: mrpt_tps_astar_planner_node
Working rationale
- Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
- On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
- The planned path is interpolated at a fixed time step and converted to a
WaypointSequence.
At startup the PTG lookup tables are built in the background, which can take
tens of seconds. The planning services and the navigate_goal action are only
offered once they are ready, so clients see them as unavailable (and can wait
for them) instead of getting a failed plan. Topic goals received meanwhile are
rejected with a warning in the log (PTGs initialized marks when the node is
ready).
The A* implementation is an anytime algorithm: it improves the solution while
time allows, then returns the best found. An optional refinement pass
(astar_skip_refine: false) further smooths the result.
Navigation goals: anytime and continuous planning
Goals from <topic_goal_sub> (e.g. clicked in RViz/Foxglove) or the
~/navigate_goal action are handled by a goal manager running in a background
thread, so the robot starts moving soon and reacts to obstacles in advance:
-
Anytime: if the search has not reached the goal after
anytime_first_path_time, the best partial path so far (the tree node closest to the goal, if it gets at leastanytime_min_progresscloser) is published, and the robot starts following it while the search goes on. -
Continuous: every
replan_period, the search root moves to a nodestitch_lookahead_timeahead of the robot along its path. The path up to it is committed (it never changes), and the search grows the same tree from there with the latest obstacles until it reaches the goal. Path updates keep the committed part, so the follower switches to them without slowing down. - Each cycle, the rest of the path is checked against the current obstacles
(robot footprint). If it is blocked, the path is cut short before the
obstacle (the follower stops there if needed) and a new search starts from
scratch: from the end of the committed part, or from the robot if the
obstacle is before it (cutting the path there, so the robot does not drive
past it meanwhile). Follower failures (
Blocked,OffPathExceeded,MissedGoal, or stayingBlockedfor 5 s) restart it from the robot pose. A search that ends with no path to follow (no motion possible from the robot pose, or no way with the current obstacles, maybe transient) is
File truncated at 100 lines see the full file
Changelog for package mrpt_tps_astar_planner_node
2.9.0 (2026-11-14)
- New NavigateWaypoints action (~/navigate_waypoints): a waypoint sequence handled as a single goal, switching to the next waypoint shortly before reaching the current one, so the robot does not stop on the way.
- NavigateWaypoints wait_if_blocked: stop and wait at obstacles blocking the path (or at a waypoint in collision) instead of detouring.
- Ignore robot speed estimates above the PTG max speed (e.g. localization jumps).
- Fix: an empty obstacle source no longer terminates the planner node.
- Relative default follower status topics (resolved in the planner namespace), and warn once if no follower status arrives.
- README: how to cite the TPS-A* planner paper.
- Contributors: Jose Luis Blanco-Claraco
2.8.0 (2026-11-01)
2.7.0 (2026-10-29)
- Adapt to mrpt_path_planning 2.x (NavEngine removed); nodes are now composable.
- Anytime and continuous planning of navigation goals with a goal manager: re-rooting, path validation against new obstacles, replanning on follower failures or blocked paths until no progress (no_progress_timeout), memory of blocking obstacles, starting from the predicted pose of moving robots.
- Navigation status stream, HUD markers and richer action feedback/results.
- PTG lookup tables built in background; services and action offered once ready, topic goals queued meanwhile.
- New parameters: turning_cost_factor, max_computation_time, anytime_max_partial_length, reverse motion cost; plan requests can ignore obstacles inside polygons.
- Reject goals whose footprint hits an obstacle; transform PoseStamped goals into the map frame.
- Costmap publishing: from the goal manager, latched for late subscribers, skipped without subscribers.
- Differential-drive demos with rotations in place (DiffDrive_Spin PTG); robot footprint topic.
- Contributors: Jose Luis Blanco-Claraco
2.6.1 (2026-10-02)
2.6.0 (2026-10-01)
- Merge pull request #176 from mrpt-ros-pkg/docs/tps-astar-planner-params
- Enable backward motion in the default PTG set
- mrpt_tps_astar_planner: document the weighted-A* and Reeds-Shepp planner options
- Merge pull request #175 from mrpt-ros-pkg/mrpt3
- Merge ros2 into mrpt3
- Declare missing MRPT 3.x package.xml dependencies
- mrpt_tps_astar_planner: link the split-off mrpt_path_planning_viz lib
- mrpt_tps_astar_planner: link against the actual mpp::mrpt_path_planning target
- Merge pull request #174 from mrpt-ros-pkg/fix/astar-planner-mpp-compat
- fix(tps_astar_planner): properly SFINAE-guard windowTitle and ptgStepIndex
- fix: sfinae to set window title on mrpt_path_planning newer versions
- tps_astar_planner: fix clang-format violation blocking CI
- tps_astar_planner_node: densify solution path before GUI render, titled window
- update to use new mpp lib structure
- Merge pull request #169 from mrpt-ros-pkg/feat/astar-footprint-aware-costmap
- feat(tps_astar_planner): footprint-aware clearance costmap (back-compatible)
- Merge pull request #168 from mrpt-ros-pkg/fix/tps-astar-concurrent-planning-race
- fix(tps_astar_planner): serialize planning to avoid concurrent PTG corruption
- Merge pull request #163 from mrpt-ros-pkg/feature/ccache-support
- build: enable ccache in all packages when available
- Port to mrpt3: fix yaml API, mrpt::opengl→viz, CImage, asCvMatRef
- Port to MRPT 3.x: rename packages and targets
- Contributors: Jose Luis Blanco-Claraco
2.5.0 (2026-05-11)
- Merge pull request #161 from mrpt-ros-pkg/fix-threads Fix threads
- fix: safer multithreading access
- Merge pull request #159
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| mrpt_navigation |
Launch files
Messages
Services
Plugins
Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange
|
mrpt_tps_astar_planner package from mrpt_navigation repomrpt_map_server mrpt_msgs_bridge mrpt_nav_interfaces mrpt_navigation mrpt_pf_localization mrpt_pointcloud_pipeline mrpt_reactivenav2d mrpt_tps_astar_planner mrpt_trajectory_follower mrpt_tutorials |
ROS Distro
|
Package Summary
| Version | 2.9.0 |
| License | BSD |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/mrpt-ros-pkg/mrpt_navigation.git |
| VCS Type | git |
| VCS Version | ros2 |
| Last Updated | 2026-11-14 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Jose-Luis Blanco-Claraco
- Shravan S Rai
Authors
- Shravan_S_Rai
- Jose-Luis Blanco-Claraco
mrpt_tps_astar_planner
Overview
This package provides a ROS 2 node that uses the PTG-based A* planner from
mrpt_path_planning to compute collision-free waypoint sequences for a
non-holonomic robot, respecting its real shape, orientation, and kinematic
constraints.
Planning is performed on a SE(2) lattice using Parameterized Trajectory
Generator (PTG) families that encode the robot’s motion primitives. The result
is published as a mrpt_msgs/WaypointSequence (and a nav_msgs/Path for
visualization) and/or returned as the response of a ROS 2 service call.
The node supports concurrent service requests: each executor thread owns a lazily-initialized planner instance, so multiple clients can request plans simultaneously without blocking each other.
How to cite
If you use this planner in your work, please cite the paper that describes it (arXiv:2611.09210):
@misc{blanco2026tpsastar,
title = {{TPS-A*}: Path Planning for Any-Shape Vehicles with Certified Collision Checking in Trajectory Parameter Space},
author = {Blanco-Claraco, Jos{\'e} Luis and Rai, Shravan S. and Ca{\~n}adas-Ar{\'a}nega, Fernando and Torres-Moreno, Jos{\'e} Luis and Moreno-{\'U}beda, Jos{\'e} Carlos},
year = {2026},
eprint = {2611.09210},
archivePrefix = {arXiv},
primaryClass = {cs.RO},
url = {https://arxiv.org/abs/2611.09210}
}
Configuration
Key configuration files passed as ROS 2 parameters:
| Parameter | Description |
|---|---|
ptg_ini |
INI file describing PTG families (robot kinematics) |
planner_parameters |
YAML file with A* algorithm parameters |
global_costmap_parameters |
YAML file for costmap obstacle-inflation parameters |
prefer_waypoints_parameters |
YAML file for waypoint-preference cost weights |
Demos
See the path-planner-sandbox/ subdirectory for standalone test scripts and
sample maps.
Node: mrpt_tps_astar_planner_node
Working rationale
- Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
- On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
- The planned path is interpolated at a fixed time step and converted to a
WaypointSequence.
At startup the PTG lookup tables are built in the background, which can take
tens of seconds. The planning services and the navigate_goal action are only
offered once they are ready, so clients see them as unavailable (and can wait
for them) instead of getting a failed plan. Topic goals received meanwhile are
rejected with a warning in the log (PTGs initialized marks when the node is
ready).
The A* implementation is an anytime algorithm: it improves the solution while
time allows, then returns the best found. An optional refinement pass
(astar_skip_refine: false) further smooths the result.
Navigation goals: anytime and continuous planning
Goals from <topic_goal_sub> (e.g. clicked in RViz/Foxglove) or the
~/navigate_goal action are handled by a goal manager running in a background
thread, so the robot starts moving soon and reacts to obstacles in advance:
-
Anytime: if the search has not reached the goal after
anytime_first_path_time, the best partial path so far (the tree node closest to the goal, if it gets at leastanytime_min_progresscloser) is published, and the robot starts following it while the search goes on. -
Continuous: every
replan_period, the search root moves to a nodestitch_lookahead_timeahead of the robot along its path. The path up to it is committed (it never changes), and the search grows the same tree from there with the latest obstacles until it reaches the goal. Path updates keep the committed part, so the follower switches to them without slowing down. - Each cycle, the rest of the path is checked against the current obstacles
(robot footprint). If it is blocked, the path is cut short before the
obstacle (the follower stops there if needed) and a new search starts from
scratch: from the end of the committed part, or from the robot if the
obstacle is before it (cutting the path there, so the robot does not drive
past it meanwhile). Follower failures (
Blocked,OffPathExceeded,MissedGoal, or stayingBlockedfor 5 s) restart it from the robot pose. A search that ends with no path to follow (no motion possible from the robot pose, or no way with the current obstacles, maybe transient) is
File truncated at 100 lines see the full file
Changelog for package mrpt_tps_astar_planner_node
2.9.0 (2026-11-14)
- New NavigateWaypoints action (~/navigate_waypoints): a waypoint sequence handled as a single goal, switching to the next waypoint shortly before reaching the current one, so the robot does not stop on the way.
- NavigateWaypoints wait_if_blocked: stop and wait at obstacles blocking the path (or at a waypoint in collision) instead of detouring.
- Ignore robot speed estimates above the PTG max speed (e.g. localization jumps).
- Fix: an empty obstacle source no longer terminates the planner node.
- Relative default follower status topics (resolved in the planner namespace), and warn once if no follower status arrives.
- README: how to cite the TPS-A* planner paper.
- Contributors: Jose Luis Blanco-Claraco
2.8.0 (2026-11-01)
2.7.0 (2026-10-29)
- Adapt to mrpt_path_planning 2.x (NavEngine removed); nodes are now composable.
- Anytime and continuous planning of navigation goals with a goal manager: re-rooting, path validation against new obstacles, replanning on follower failures or blocked paths until no progress (no_progress_timeout), memory of blocking obstacles, starting from the predicted pose of moving robots.
- Navigation status stream, HUD markers and richer action feedback/results.
- PTG lookup tables built in background; services and action offered once ready, topic goals queued meanwhile.
- New parameters: turning_cost_factor, max_computation_time, anytime_max_partial_length, reverse motion cost; plan requests can ignore obstacles inside polygons.
- Reject goals whose footprint hits an obstacle; transform PoseStamped goals into the map frame.
- Costmap publishing: from the goal manager, latched for late subscribers, skipped without subscribers.
- Differential-drive demos with rotations in place (DiffDrive_Spin PTG); robot footprint topic.
- Contributors: Jose Luis Blanco-Claraco
2.6.1 (2026-10-02)
2.6.0 (2026-10-01)
- Merge pull request #176 from mrpt-ros-pkg/docs/tps-astar-planner-params
- Enable backward motion in the default PTG set
- mrpt_tps_astar_planner: document the weighted-A* and Reeds-Shepp planner options
- Merge pull request #175 from mrpt-ros-pkg/mrpt3
- Merge ros2 into mrpt3
- Declare missing MRPT 3.x package.xml dependencies
- mrpt_tps_astar_planner: link the split-off mrpt_path_planning_viz lib
- mrpt_tps_astar_planner: link against the actual mpp::mrpt_path_planning target
- Merge pull request #174 from mrpt-ros-pkg/fix/astar-planner-mpp-compat
- fix(tps_astar_planner): properly SFINAE-guard windowTitle and ptgStepIndex
- fix: sfinae to set window title on mrpt_path_planning newer versions
- tps_astar_planner: fix clang-format violation blocking CI
- tps_astar_planner_node: densify solution path before GUI render, titled window
- update to use new mpp lib structure
- Merge pull request #169 from mrpt-ros-pkg/feat/astar-footprint-aware-costmap
- feat(tps_astar_planner): footprint-aware clearance costmap (back-compatible)
- Merge pull request #168 from mrpt-ros-pkg/fix/tps-astar-concurrent-planning-race
- fix(tps_astar_planner): serialize planning to avoid concurrent PTG corruption
- Merge pull request #163 from mrpt-ros-pkg/feature/ccache-support
- build: enable ccache in all packages when available
- Port to mrpt3: fix yaml API, mrpt::opengl→viz, CImage, asCvMatRef
- Port to MRPT 3.x: rename packages and targets
- Contributors: Jose Luis Blanco-Claraco
2.5.0 (2026-05-11)
- Merge pull request #161 from mrpt-ros-pkg/fix-threads Fix threads
- fix: safer multithreading access
- Merge pull request #159
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| mrpt_navigation |
Launch files
Messages
Services
Plugins
Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange
|
mrpt_tps_astar_planner package from mrpt_navigation repomrpt_map_server mrpt_msgs_bridge mrpt_nav_interfaces mrpt_navigation mrpt_pf_localization mrpt_pointcloud_pipeline mrpt_reactivenav2d mrpt_tps_astar_planner mrpt_trajectory_follower mrpt_tutorials |
ROS Distro
|
Package Summary
| Version | 2.9.0 |
| License | BSD |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/mrpt-ros-pkg/mrpt_navigation.git |
| VCS Type | git |
| VCS Version | ros2 |
| Last Updated | 2026-11-14 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Jose-Luis Blanco-Claraco
- Shravan S Rai
Authors
- Shravan_S_Rai
- Jose-Luis Blanco-Claraco
mrpt_tps_astar_planner
Overview
This package provides a ROS 2 node that uses the PTG-based A* planner from
mrpt_path_planning to compute collision-free waypoint sequences for a
non-holonomic robot, respecting its real shape, orientation, and kinematic
constraints.
Planning is performed on a SE(2) lattice using Parameterized Trajectory
Generator (PTG) families that encode the robot’s motion primitives. The result
is published as a mrpt_msgs/WaypointSequence (and a nav_msgs/Path for
visualization) and/or returned as the response of a ROS 2 service call.
The node supports concurrent service requests: each executor thread owns a lazily-initialized planner instance, so multiple clients can request plans simultaneously without blocking each other.
How to cite
If you use this planner in your work, please cite the paper that describes it (arXiv:2611.09210):
@misc{blanco2026tpsastar,
title = {{TPS-A*}: Path Planning for Any-Shape Vehicles with Certified Collision Checking in Trajectory Parameter Space},
author = {Blanco-Claraco, Jos{\'e} Luis and Rai, Shravan S. and Ca{\~n}adas-Ar{\'a}nega, Fernando and Torres-Moreno, Jos{\'e} Luis and Moreno-{\'U}beda, Jos{\'e} Carlos},
year = {2026},
eprint = {2611.09210},
archivePrefix = {arXiv},
primaryClass = {cs.RO},
url = {https://arxiv.org/abs/2611.09210}
}
Configuration
Key configuration files passed as ROS 2 parameters:
| Parameter | Description |
|---|---|
ptg_ini |
INI file describing PTG families (robot kinematics) |
planner_parameters |
YAML file with A* algorithm parameters |
global_costmap_parameters |
YAML file for costmap obstacle-inflation parameters |
prefer_waypoints_parameters |
YAML file for waypoint-preference cost weights |
Demos
See the path-planner-sandbox/ subdirectory for standalone test scripts and
sample maps.
Node: mrpt_tps_astar_planner_node
Working rationale
- Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
- On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
- The planned path is interpolated at a fixed time step and converted to a
WaypointSequence.
At startup the PTG lookup tables are built in the background, which can take
tens of seconds. The planning services and the navigate_goal action are only
offered once they are ready, so clients see them as unavailable (and can wait
for them) instead of getting a failed plan. Topic goals received meanwhile are
rejected with a warning in the log (PTGs initialized marks when the node is
ready).
The A* implementation is an anytime algorithm: it improves the solution while
time allows, then returns the best found. An optional refinement pass
(astar_skip_refine: false) further smooths the result.
Navigation goals: anytime and continuous planning
Goals from <topic_goal_sub> (e.g. clicked in RViz/Foxglove) or the
~/navigate_goal action are handled by a goal manager running in a background
thread, so the robot starts moving soon and reacts to obstacles in advance:
-
Anytime: if the search has not reached the goal after
anytime_first_path_time, the best partial path so far (the tree node closest to the goal, if it gets at leastanytime_min_progresscloser) is published, and the robot starts following it while the search goes on. -
Continuous: every
replan_period, the search root moves to a nodestitch_lookahead_timeahead of the robot along its path. The path up to it is committed (it never changes), and the search grows the same tree from there with the latest obstacles until it reaches the goal. Path updates keep the committed part, so the follower switches to them without slowing down. - Each cycle, the rest of the path is checked against the current obstacles
(robot footprint). If it is blocked, the path is cut short before the
obstacle (the follower stops there if needed) and a new search starts from
scratch: from the end of the committed part, or from the robot if the
obstacle is before it (cutting the path there, so the robot does not drive
past it meanwhile). Follower failures (
Blocked,OffPathExceeded,MissedGoal, or stayingBlockedfor 5 s) restart it from the robot pose. A search that ends with no path to follow (no motion possible from the robot pose, or no way with the current obstacles, maybe transient) is
File truncated at 100 lines see the full file
Changelog for package mrpt_tps_astar_planner_node
2.9.0 (2026-11-14)
- New NavigateWaypoints action (~/navigate_waypoints): a waypoint sequence handled as a single goal, switching to the next waypoint shortly before reaching the current one, so the robot does not stop on the way.
- NavigateWaypoints wait_if_blocked: stop and wait at obstacles blocking the path (or at a waypoint in collision) instead of detouring.
- Ignore robot speed estimates above the PTG max speed (e.g. localization jumps).
- Fix: an empty obstacle source no longer terminates the planner node.
- Relative default follower status topics (resolved in the planner namespace), and warn once if no follower status arrives.
- README: how to cite the TPS-A* planner paper.
- Contributors: Jose Luis Blanco-Claraco
2.8.0 (2026-11-01)
2.7.0 (2026-10-29)
- Adapt to mrpt_path_planning 2.x (NavEngine removed); nodes are now composable.
- Anytime and continuous planning of navigation goals with a goal manager: re-rooting, path validation against new obstacles, replanning on follower failures or blocked paths until no progress (no_progress_timeout), memory of blocking obstacles, starting from the predicted pose of moving robots.
- Navigation status stream, HUD markers and richer action feedback/results.
- PTG lookup tables built in background; services and action offered once ready, topic goals queued meanwhile.
- New parameters: turning_cost_factor, max_computation_time, anytime_max_partial_length, reverse motion cost; plan requests can ignore obstacles inside polygons.
- Reject goals whose footprint hits an obstacle; transform PoseStamped goals into the map frame.
- Costmap publishing: from the goal manager, latched for late subscribers, skipped without subscribers.
- Differential-drive demos with rotations in place (DiffDrive_Spin PTG); robot footprint topic.
- Contributors: Jose Luis Blanco-Claraco
2.6.1 (2026-10-02)
2.6.0 (2026-10-01)
- Merge pull request #176 from mrpt-ros-pkg/docs/tps-astar-planner-params
- Enable backward motion in the default PTG set
- mrpt_tps_astar_planner: document the weighted-A* and Reeds-Shepp planner options
- Merge pull request #175 from mrpt-ros-pkg/mrpt3
- Merge ros2 into mrpt3
- Declare missing MRPT 3.x package.xml dependencies
- mrpt_tps_astar_planner: link the split-off mrpt_path_planning_viz lib
- mrpt_tps_astar_planner: link against the actual mpp::mrpt_path_planning target
- Merge pull request #174 from mrpt-ros-pkg/fix/astar-planner-mpp-compat
- fix(tps_astar_planner): properly SFINAE-guard windowTitle and ptgStepIndex
- fix: sfinae to set window title on mrpt_path_planning newer versions
- tps_astar_planner: fix clang-format violation blocking CI
- tps_astar_planner_node: densify solution path before GUI render, titled window
- update to use new mpp lib structure
- Merge pull request #169 from mrpt-ros-pkg/feat/astar-footprint-aware-costmap
- feat(tps_astar_planner): footprint-aware clearance costmap (back-compatible)
- Merge pull request #168 from mrpt-ros-pkg/fix/tps-astar-concurrent-planning-race
- fix(tps_astar_planner): serialize planning to avoid concurrent PTG corruption
- Merge pull request #163 from mrpt-ros-pkg/feature/ccache-support
- build: enable ccache in all packages when available
- Port to mrpt3: fix yaml API, mrpt::opengl→viz, CImage, asCvMatRef
- Port to MRPT 3.x: rename packages and targets
- Contributors: Jose Luis Blanco-Claraco
2.5.0 (2026-05-11)
- Merge pull request #161 from mrpt-ros-pkg/fix-threads Fix threads
- fix: safer multithreading access
- Merge pull request #159
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| mrpt_navigation |
Launch files
Messages
Services
Plugins
Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange
|
mrpt_tps_astar_planner package from mrpt_navigation repomrpt_map_server mrpt_msgs_bridge mrpt_nav_interfaces mrpt_navigation mrpt_pf_localization mrpt_pointcloud_pipeline mrpt_reactivenav2d mrpt_tps_astar_planner mrpt_trajectory_follower mrpt_tutorials |
ROS Distro
|
Package Summary
| Version | 2.9.0 |
| License | BSD |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/mrpt-ros-pkg/mrpt_navigation.git |
| VCS Type | git |
| VCS Version | ros2 |
| Last Updated | 2026-11-14 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Jose-Luis Blanco-Claraco
- Shravan S Rai
Authors
- Shravan_S_Rai
- Jose-Luis Blanco-Claraco
mrpt_tps_astar_planner
Overview
This package provides a ROS 2 node that uses the PTG-based A* planner from
mrpt_path_planning to compute collision-free waypoint sequences for a
non-holonomic robot, respecting its real shape, orientation, and kinematic
constraints.
Planning is performed on a SE(2) lattice using Parameterized Trajectory
Generator (PTG) families that encode the robot’s motion primitives. The result
is published as a mrpt_msgs/WaypointSequence (and a nav_msgs/Path for
visualization) and/or returned as the response of a ROS 2 service call.
The node supports concurrent service requests: each executor thread owns a lazily-initialized planner instance, so multiple clients can request plans simultaneously without blocking each other.
How to cite
If you use this planner in your work, please cite the paper that describes it (arXiv:2611.09210):
@misc{blanco2026tpsastar,
title = {{TPS-A*}: Path Planning for Any-Shape Vehicles with Certified Collision Checking in Trajectory Parameter Space},
author = {Blanco-Claraco, Jos{\'e} Luis and Rai, Shravan S. and Ca{\~n}adas-Ar{\'a}nega, Fernando and Torres-Moreno, Jos{\'e} Luis and Moreno-{\'U}beda, Jos{\'e} Carlos},
year = {2026},
eprint = {2611.09210},
archivePrefix = {arXiv},
primaryClass = {cs.RO},
url = {https://arxiv.org/abs/2611.09210}
}
Configuration
Key configuration files passed as ROS 2 parameters:
| Parameter | Description |
|---|---|
ptg_ini |
INI file describing PTG families (robot kinematics) |
planner_parameters |
YAML file with A* algorithm parameters |
global_costmap_parameters |
YAML file for costmap obstacle-inflation parameters |
prefer_waypoints_parameters |
YAML file for waypoint-preference cost weights |
Demos
See the path-planner-sandbox/ subdirectory for standalone test scripts and
sample maps.
Node: mrpt_tps_astar_planner_node
Working rationale
- Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
- On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
- The planned path is interpolated at a fixed time step and converted to a
WaypointSequence.
At startup the PTG lookup tables are built in the background, which can take
tens of seconds. The planning services and the navigate_goal action are only
offered once they are ready, so clients see them as unavailable (and can wait
for them) instead of getting a failed plan. Topic goals received meanwhile are
rejected with a warning in the log (PTGs initialized marks when the node is
ready).
The A* implementation is an anytime algorithm: it improves the solution while
time allows, then returns the best found. An optional refinement pass
(astar_skip_refine: false) further smooths the result.
Navigation goals: anytime and continuous planning
Goals from <topic_goal_sub> (e.g. clicked in RViz/Foxglove) or the
~/navigate_goal action are handled by a goal manager running in a background
thread, so the robot starts moving soon and reacts to obstacles in advance:
-
Anytime: if the search has not reached the goal after
anytime_first_path_time, the best partial path so far (the tree node closest to the goal, if it gets at leastanytime_min_progresscloser) is published, and the robot starts following it while the search goes on. -
Continuous: every
replan_period, the search root moves to a nodestitch_lookahead_timeahead of the robot along its path. The path up to it is committed (it never changes), and the search grows the same tree from there with the latest obstacles until it reaches the goal. Path updates keep the committed part, so the follower switches to them without slowing down. - Each cycle, the rest of the path is checked against the current obstacles
(robot footprint). If it is blocked, the path is cut short before the
obstacle (the follower stops there if needed) and a new search starts from
scratch: from the end of the committed part, or from the robot if the
obstacle is before it (cutting the path there, so the robot does not drive
past it meanwhile). Follower failures (
Blocked,OffPathExceeded,MissedGoal, or stayingBlockedfor 5 s) restart it from the robot pose. A search that ends with no path to follow (no motion possible from the robot pose, or no way with the current obstacles, maybe transient) is
File truncated at 100 lines see the full file
Changelog for package mrpt_tps_astar_planner_node
2.9.0 (2026-11-14)
- New NavigateWaypoints action (~/navigate_waypoints): a waypoint sequence handled as a single goal, switching to the next waypoint shortly before reaching the current one, so the robot does not stop on the way.
- NavigateWaypoints wait_if_blocked: stop and wait at obstacles blocking the path (or at a waypoint in collision) instead of detouring.
- Ignore robot speed estimates above the PTG max speed (e.g. localization jumps).
- Fix: an empty obstacle source no longer terminates the planner node.
- Relative default follower status topics (resolved in the planner namespace), and warn once if no follower status arrives.
- README: how to cite the TPS-A* planner paper.
- Contributors: Jose Luis Blanco-Claraco
2.8.0 (2026-11-01)
2.7.0 (2026-10-29)
- Adapt to mrpt_path_planning 2.x (NavEngine removed); nodes are now composable.
- Anytime and continuous planning of navigation goals with a goal manager: re-rooting, path validation against new obstacles, replanning on follower failures or blocked paths until no progress (no_progress_timeout), memory of blocking obstacles, starting from the predicted pose of moving robots.
- Navigation status stream, HUD markers and richer action feedback/results.
- PTG lookup tables built in background; services and action offered once ready, topic goals queued meanwhile.
- New parameters: turning_cost_factor, max_computation_time, anytime_max_partial_length, reverse motion cost; plan requests can ignore obstacles inside polygons.
- Reject goals whose footprint hits an obstacle; transform PoseStamped goals into the map frame.
- Costmap publishing: from the goal manager, latched for late subscribers, skipped without subscribers.
- Differential-drive demos with rotations in place (DiffDrive_Spin PTG); robot footprint topic.
- Contributors: Jose Luis Blanco-Claraco
2.6.1 (2026-10-02)
2.6.0 (2026-10-01)
- Merge pull request #176 from mrpt-ros-pkg/docs/tps-astar-planner-params
- Enable backward motion in the default PTG set
- mrpt_tps_astar_planner: document the weighted-A* and Reeds-Shepp planner options
- Merge pull request #175 from mrpt-ros-pkg/mrpt3
- Merge ros2 into mrpt3
- Declare missing MRPT 3.x package.xml dependencies
- mrpt_tps_astar_planner: link the split-off mrpt_path_planning_viz lib
- mrpt_tps_astar_planner: link against the actual mpp::mrpt_path_planning target
- Merge pull request #174 from mrpt-ros-pkg/fix/astar-planner-mpp-compat
- fix(tps_astar_planner): properly SFINAE-guard windowTitle and ptgStepIndex
- fix: sfinae to set window title on mrpt_path_planning newer versions
- tps_astar_planner: fix clang-format violation blocking CI
- tps_astar_planner_node: densify solution path before GUI render, titled window
- update to use new mpp lib structure
- Merge pull request #169 from mrpt-ros-pkg/feat/astar-footprint-aware-costmap
- feat(tps_astar_planner): footprint-aware clearance costmap (back-compatible)
- Merge pull request #168 from mrpt-ros-pkg/fix/tps-astar-concurrent-planning-race
- fix(tps_astar_planner): serialize planning to avoid concurrent PTG corruption
- Merge pull request #163 from mrpt-ros-pkg/feature/ccache-support
- build: enable ccache in all packages when available
- Port to mrpt3: fix yaml API, mrpt::opengl→viz, CImage, asCvMatRef
- Port to MRPT 3.x: rename packages and targets
- Contributors: Jose Luis Blanco-Claraco
2.5.0 (2026-05-11)
- Merge pull request #161 from mrpt-ros-pkg/fix-threads Fix threads
- fix: safer multithreading access
- Merge pull request #159
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| mrpt_navigation |
Launch files
Messages
Services
Plugins
Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange
|
mrpt_tps_astar_planner package from mrpt_navigation repomrpt_map_server mrpt_msgs_bridge mrpt_nav_interfaces mrpt_navigation mrpt_pf_localization mrpt_pointcloud_pipeline mrpt_reactivenav2d mrpt_tps_astar_planner mrpt_trajectory_follower mrpt_tutorials |
ROS Distro
|
Package Summary
| Version | 2.9.0 |
| License | BSD |
| Build type | AMENT_CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | |
| Checkout URI | https://github.com/mrpt-ros-pkg/mrpt_navigation.git |
| VCS Type | git |
| VCS Version | ros2 |
| Last Updated | 2026-11-14 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Jose-Luis Blanco-Claraco
- Shravan S Rai
Authors
- Shravan_S_Rai
- Jose-Luis Blanco-Claraco
mrpt_tps_astar_planner
Overview
This package provides a ROS 2 node that uses the PTG-based A* planner from
mrpt_path_planning to compute collision-free waypoint sequences for a
non-holonomic robot, respecting its real shape, orientation, and kinematic
constraints.
Planning is performed on a SE(2) lattice using Parameterized Trajectory
Generator (PTG) families that encode the robot’s motion primitives. The result
is published as a mrpt_msgs/WaypointSequence (and a nav_msgs/Path for
visualization) and/or returned as the response of a ROS 2 service call.
The node supports concurrent service requests: each executor thread owns a lazily-initialized planner instance, so multiple clients can request plans simultaneously without blocking each other.
How to cite
If you use this planner in your work, please cite the paper that describes it (arXiv:2611.09210):
@misc{blanco2026tpsastar,
title = {{TPS-A*}: Path Planning for Any-Shape Vehicles with Certified Collision Checking in Trajectory Parameter Space},
author = {Blanco-Claraco, Jos{\'e} Luis and Rai, Shravan S. and Ca{\~n}adas-Ar{\'a}nega, Fernando and Torres-Moreno, Jos{\'e} Luis and Moreno-{\'U}beda, Jos{\'e} Carlos},
year = {2026},
eprint = {2611.09210},
archivePrefix = {arXiv},
primaryClass = {cs.RO},
url = {https://arxiv.org/abs/2611.09210}
}
Configuration
Key configuration files passed as ROS 2 parameters:
| Parameter | Description |
|---|---|
ptg_ini |
INI file describing PTG families (robot kinematics) |
planner_parameters |
YAML file with A* algorithm parameters |
global_costmap_parameters |
YAML file for costmap obstacle-inflation parameters |
prefer_waypoints_parameters |
YAML file for waypoint-preference cost weights |
Demos
See the path-planner-sandbox/ subdirectory for standalone test scripts and
sample maps.
Node: mrpt_tps_astar_planner_node
Working rationale
- Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
- On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
- The planned path is interpolated at a fixed time step and converted to a
WaypointSequence.
At startup the PTG lookup tables are built in the background, which can take
tens of seconds. The planning services and the navigate_goal action are only
offered once they are ready, so clients see them as unavailable (and can wait
for them) instead of getting a failed plan. Topic goals received meanwhile are
rejected with a warning in the log (PTGs initialized marks when the node is
ready).
The A* implementation is an anytime algorithm: it improves the solution while
time allows, then returns the best found. An optional refinement pass
(astar_skip_refine: false) further smooths the result.
Navigation goals: anytime and continuous planning
Goals from <topic_goal_sub> (e.g. clicked in RViz/Foxglove) or the
~/navigate_goal action are handled by a goal manager running in a background
thread, so the robot starts moving soon and reacts to obstacles in advance:
-
Anytime: if the search has not reached the goal after
anytime_first_path_time, the best partial path so far (the tree node closest to the goal, if it gets at leastanytime_min_progresscloser) is published, and the robot starts following it while the search goes on. -
Continuous: every
replan_period, the search root moves to a nodestitch_lookahead_timeahead of the robot along its path. The path up to it is committed (it never changes), and the search grows the same tree from there with the latest obstacles until it reaches the goal. Path updates keep the committed part, so the follower switches to them without slowing down. - Each cycle, the rest of the path is checked against the current obstacles
(robot footprint). If it is blocked, the path is cut short before the
obstacle (the follower stops there if needed) and a new search starts from
scratch: from the end of the committed part, or from the robot if the
obstacle is before it (cutting the path there, so the robot does not drive
past it meanwhile). Follower failures (
Blocked,OffPathExceeded,MissedGoal, or stayingBlockedfor 5 s) restart it from the robot pose. A search that ends with no path to follow (no motion possible from the robot pose, or no way with the current obstacles, maybe transient) is
File truncated at 100 lines see the full file
Changelog for package mrpt_tps_astar_planner_node
2.9.0 (2026-11-14)
- New NavigateWaypoints action (~/navigate_waypoints): a waypoint sequence handled as a single goal, switching to the next waypoint shortly before reaching the current one, so the robot does not stop on the way.
- NavigateWaypoints wait_if_blocked: stop and wait at obstacles blocking the path (or at a waypoint in collision) instead of detouring.
- Ignore robot speed estimates above the PTG max speed (e.g. localization jumps).
- Fix: an empty obstacle source no longer terminates the planner node.
- Relative default follower status topics (resolved in the planner namespace), and warn once if no follower status arrives.
- README: how to cite the TPS-A* planner paper.
- Contributors: Jose Luis Blanco-Claraco
2.8.0 (2026-11-01)
2.7.0 (2026-10-29)
- Adapt to mrpt_path_planning 2.x (NavEngine removed); nodes are now composable.
- Anytime and continuous planning of navigation goals with a goal manager: re-rooting, path validation against new obstacles, replanning on follower failures or blocked paths until no progress (no_progress_timeout), memory of blocking obstacles, starting from the predicted pose of moving robots.
- Navigation status stream, HUD markers and richer action feedback/results.
- PTG lookup tables built in background; services and action offered once ready, topic goals queued meanwhile.
- New parameters: turning_cost_factor, max_computation_time, anytime_max_partial_length, reverse motion cost; plan requests can ignore obstacles inside polygons.
- Reject goals whose footprint hits an obstacle; transform PoseStamped goals into the map frame.
- Costmap publishing: from the goal manager, latched for late subscribers, skipped without subscribers.
- Differential-drive demos with rotations in place (DiffDrive_Spin PTG); robot footprint topic.
- Contributors: Jose Luis Blanco-Claraco
2.6.1 (2026-10-02)
2.6.0 (2026-10-01)
- Merge pull request #176 from mrpt-ros-pkg/docs/tps-astar-planner-params
- Enable backward motion in the default PTG set
- mrpt_tps_astar_planner: document the weighted-A* and Reeds-Shepp planner options
- Merge pull request #175 from mrpt-ros-pkg/mrpt3
- Merge ros2 into mrpt3
- Declare missing MRPT 3.x package.xml dependencies
- mrpt_tps_astar_planner: link the split-off mrpt_path_planning_viz lib
- mrpt_tps_astar_planner: link against the actual mpp::mrpt_path_planning target
- Merge pull request #174 from mrpt-ros-pkg/fix/astar-planner-mpp-compat
- fix(tps_astar_planner): properly SFINAE-guard windowTitle and ptgStepIndex
- fix: sfinae to set window title on mrpt_path_planning newer versions
- tps_astar_planner: fix clang-format violation blocking CI
- tps_astar_planner_node: densify solution path before GUI render, titled window
- update to use new mpp lib structure
- Merge pull request #169 from mrpt-ros-pkg/feat/astar-footprint-aware-costmap
- feat(tps_astar_planner): footprint-aware clearance costmap (back-compatible)
- Merge pull request #168 from mrpt-ros-pkg/fix/tps-astar-concurrent-planning-race
- fix(tps_astar_planner): serialize planning to avoid concurrent PTG corruption
- Merge pull request #163 from mrpt-ros-pkg/feature/ccache-support
- build: enable ccache in all packages when available
- Port to mrpt3: fix yaml API, mrpt::opengl→viz, CImage, asCvMatRef
- Port to MRPT 3.x: rename packages and targets
- Contributors: Jose Luis Blanco-Claraco
2.5.0 (2026-05-11)
- Merge pull request #161 from mrpt-ros-pkg/fix-threads Fix threads
- fix: safer multithreading access
- Merge pull request #159
File truncated at 100 lines see the full file
Package Dependencies
System Dependencies
Dependant Packages
| Name | Deps |
|---|---|
| mrpt_navigation |