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

ROS Path Planner with A* in TP-Space Engine

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

  1. Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
  2. On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
  3. 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.

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:

  1. 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 least anytime_min_progress closer) is published, and the robot starts following it while the search goes on.
  2. Continuous: every replan_period, the search root moves to a node stitch_lookahead_time ahead 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.
  3. 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 staying Blocked for 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

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

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange

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

ROS Path Planner with A* in TP-Space Engine

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

  1. Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
  2. On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
  3. 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.

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:

  1. 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 least anytime_min_progress closer) is published, and the robot starts following it while the search goes on.
  2. Continuous: every replan_period, the search root moves to a node stitch_lookahead_time ahead 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.
  3. 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 staying Blocked for 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

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

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange

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

ROS Path Planner with A* in TP-Space Engine

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

  1. Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
  2. On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
  3. 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.

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:

  1. 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 least anytime_min_progress closer) is published, and the robot starts following it while the search goes on.
  2. Continuous: every replan_period, the search root moves to a node stitch_lookahead_time ahead 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.
  3. 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 staying Blocked for 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

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

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange

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

ROS Path Planner with A* in TP-Space Engine

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

  1. Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
  2. On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
  3. 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.

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:

  1. 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 least anytime_min_progress closer) is published, and the robot starts following it while the search goes on.
  2. Continuous: every replan_period, the search root moves to a node stitch_lookahead_time ahead 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.
  3. 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 staying Blocked for 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

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

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange

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

ROS Path Planner with A* in TP-Space Engine

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

  1. Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
  2. On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
  3. 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.

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:

  1. 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 least anytime_min_progress closer) is published, and the robot starts following it while the search goes on.
  2. Continuous: every replan_period, the search root moves to a node stitch_lookahead_time ahead 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.
  3. 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 staying Blocked for 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

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

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange

No version for distro github showing humble. Known supported distros are highlighted in the buttons above.

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

ROS Path Planner with A* in TP-Space Engine

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

  1. Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
  2. On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
  3. 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.

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:

  1. 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 least anytime_min_progress closer) is published, and the robot starts following it while the search goes on.
  2. Continuous: every replan_period, the search root moves to a node stitch_lookahead_time ahead 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.
  3. 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 staying Blocked for 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

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

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange

No version for distro galactic showing humble. Known supported distros are highlighted in the buttons above.

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

ROS Path Planner with A* in TP-Space Engine

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

  1. Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
  2. On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
  3. 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.

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:

  1. 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 least anytime_min_progress closer) is published, and the robot starts following it while the search goes on.
  2. Continuous: every replan_period, the search root moves to a node stitch_lookahead_time ahead 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.
  3. 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 staying Blocked for 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

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

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange

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

ROS Path Planner with A* in TP-Space Engine

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

  1. Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
  2. On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
  3. 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.

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:

  1. 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 least anytime_min_progress closer) is published, and the robot starts following it while the search goes on.
  2. Continuous: every replan_period, the search root moves to a node stitch_lookahead_time ahead 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.
  3. 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 staying Blocked for 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

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

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange

No version for distro melodic showing humble. Known supported distros are highlighted in the buttons above.

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

ROS Path Planner with A* in TP-Space Engine

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

  1. Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
  2. On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
  3. 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.

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:

  1. 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 least anytime_min_progress closer) is published, and the robot starts following it while the search goes on.
  2. Continuous: every replan_period, the search root moves to a node stitch_lookahead_time ahead 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.
  3. 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 staying Blocked for 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

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

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange

No version for distro noetic showing humble. Known supported distros are highlighted in the buttons above.

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

ROS Path Planner with A* in TP-Space Engine

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

  1. Obstacle data are maintained from subscribed gridmaps and/or point-cloud topics (updated asynchronously, protected by a mutex).
  2. On each planning request (topic goal or service call) the node snapshots the current obstacle data, builds cost evaluators, and runs the A* planner.
  3. 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.

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:

  1. 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 least anytime_min_progress closer) is published, and the robot starts following it while the search goes on.
  2. Continuous: every replan_period, the search root moves to a node stitch_lookahead_time ahead 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.
  3. 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 staying Blocked for 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

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

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged mrpt_tps_astar_planner at Robotics Stack Exchange