|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file
CONTRIBUTING
|
mrpt_path_planning repositorymrpt_path_planning mrpt_path_planning_apps mrpt_path_planning_core |
ROS Distro
|
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-10-06 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 2.0.0 |
| mrpt_path_planning_apps | 2.0.0 |
| mrpt_path_planning_core | 2.0.0 |
README
mrpt_path_planning
Kinematically-feasible path planning for robots and vehicles on planar
environments, for arbitrary robot shapes and realistic kinematics
(differential-drive, Ackermann, holonomic). Built on
MRPT mrpt_nav and the theory of
Parameterized Trajectory Generators (PTGs), which act as libraries of motion
primitives.
Planned paths for a holonomic robot (left) and an Ackermann vehicle (right).
Features
- Kinematically feasible by construction: every path is a sequence of PTG trajectories the vehicle can actually execute, respecting its turning and speed limits. Several PTG families can be mixed in one search, and speed-trimmable PTGs make the search velocity-aware.
- Any-shape vehicles: circular or arbitrary polygonal footprints, including concave ones. The footprint is baked once into per-PTG collision grids, so the per-node collision cost does not grow with the footprint complexity: one pass over the local obstacles gives the free distance along every candidate trajectory.
- No costmap inflation: the actual footprint is checked against the raw obstacle points, with no inflation radius to tune.
-
Deterministic SE(2) lattice A* (
mpp::TPS_Astar) and a bidirectional variant (mpp::TPS_Astar_Bidir). They optimize SE(2) cost (position + heading), not just Euclidean length, with optional bounded-suboptimal weighted A* for faster queries. -
Pose or position goals: SE(2) goals
[x y phi]or heading-agnostic R(2) goals[x y]. - Forward and reverse maneuvers, with an optional Reeds-Shepp heuristic and analytic goal expansion for tight maneuvers such as parking.
- Certified collision checking: the collision grids are conservative, so a path reported as free is free for the continuous swept motion.
- Pluggable cost layers: obstacle-proximity cost maps, preferred-waypoint attractors, and a penalty for driving in reverse.
-
Navigation building blocks:
TrajectoryFollower(pure pursuit with predictive safety, valid at any speed), andCollisionGuard(last-resort velocity filter ensuring the robot can always stop before sensed obstacles). - Headless core: the algorithms library has no GUI dependency.
Quick start
Install the binary packages (ROS 2 Humble or newer):
sudo apt install ros-$ROS_DISTRO-mrpt-path-planning
Plan a path around some obstacles for a holonomic robot, using the example configuration files installed with the apps package:
cd $(ros2 pkg prefix mrpt_path_planning_apps)/share/mrpt_path_planning_apps
path-planner-cli \
-s "[0.5 0 0]" -g "[4.2 0.5 80]" \
-c ptgs_holonomic_robot.ini \
--obstacles obstacles_01.txt \
--planner-parameters mvsim-demo-astar-planner-params.yaml \
--play-animation
Packages
| Package | Contents | Depend on it when… |
|---|---|---|
mrpt_path_planning_core |
C++ library (namespace mpp): PTGs, planners, cost evaluators, TrajectoryFollower. Depends only on mrpt_nav, mrpt_maps, mrpt_graphs, mrpt_containers. |
You only need the algorithms (most users). |
mrpt_path_planning_apps |
path-planner-cli, selfdriving-simulator-gui, example config files. Adds mrpt_gui, cli11, mvsim. |
You want the command-line and GUI tools. |
mrpt_path_planning |
Metapackage depending on the two above. | Backward compatibility with existing consumers. |
ROS 2 integration (planner and trajectory follower nodes) lives in mrpt_navigation.
Using the library
In package.xml:
<depend>mrpt_path_planning_core</depend>
File truncated at 100 lines see the full file