|
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
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-07-16 |
| 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
Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of “motion primitives” for vehicles with arbitrary shape and realistic kinematics and dynamics.
The planner optimizes SE(2) path cost (position + heading), not R(2) path length.
For vehicles that rotate, arriving at a goal with the correct heading is part of the
optimal solution — paths that are longer in Euclidean distance but better-aligned
may genuinely have lower cost. See TPS_Astar.h for details on the cost model.
Status on ROS build farm
| Distro | Build dev | Build releases | Stable version |
|---|---|---|---|
| ROS 2 Humble (u22.04) | |||
| ROS 2 Jazzy @ u24.04 | |||
| ROS 2 Kilted @ u24.04 | |||
| ROS 2 Lyrical (u26.04) | |||
| ROS 2 Rolling (u26.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Package layout
This repository is split into three colcon/ROS 2 packages:
-
mrpt_path_planning_core: the headless C++ path-planning library (PTGs,TPS_Astar,NavEngine,TrajectoryFollower, …). No GUI/display dependency — depends only onmrpt_libmaps,mrpt_libnav,mrpt_libgraphs,mrpt_libcontainers,mrpt_libtclap. -
mrpt_path_planning_apps: the CLI and GUI applications (path-planner-cli, which opens a 3D viz window, andselfdriving-simulator-gui, which requiresmvsim). Depends onmrpt_path_planning_coreplusmrpt_libguiandmvsim. -
mrpt_path_planning: a backward-compatible metapackage with no code of its own — it just depends on the two packages above, so existing<depend>mrpt_path_planning</depend>consumers keep working unchanged. New consumers that only need the algorithms should depend onmrpt_path_planning_coredirectly to avoid pulling inmrpt_libgui.
Build requisites
- MRPT (>=2.12.0)
- mvsim (optional to run the live control simulator).
- colcon — this repo is colcon-only; there is no standalone top-level CMake build.
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev python3-colcon-common-extensions
For older versions of Ubuntu:
# MRPT from this PPA (or build from sources if preferred, or from ROS package `mrpt2`):
sudo add-apt-repository ppa:joseluisblancoc/mrpt
sudo apt update
sudo apt install libmrpt-dev python3-colcon-common-extensions
Build (from the directory containing this repo, e.g. a colcon workspace src/):
colcon build --base-paths .
source install/setup.bash
Use in your code
From your CMake script:
find_package(mrpt_path_planning_core REQUIRED) # or mrpt_path_planning for backward compat
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
And in package.xml, prefer <depend>mrpt_path_planning_core</depend> unless
you also need the CLI/GUI apps.
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
path-planner-cli --write-planner-parameters my-planner-params.yaml
Plan a path for a holonomic robot with an SE(2) goal pose (x y heading_deg),
File truncated at 100 lines see the full file