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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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

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

README

mrpt_path_planning

CI Linux License: BSD-3 ROS 2 Jazzy

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.

Holonomic robot following a planned path Ackermann vehicle following a planned path
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), and CollisionGuard (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