Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/MRPT/mrpt_path_planning.git |
| VCS Type | git |
| VCS Version | develop |
| Last Updated | 2026-03-18 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| mrpt_path_planning | 0.2.5 |
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 Rolling (u24.04) |
| EOL Distro | Last version |
|---|---|
| ROS 1 Noetic (u20.04) | |
| ROS 2 Iron (u22.04) |
Build requisites
In Ubuntu 22.04 or newer, installed it with:
sudo apt install libmrpt-dev
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
Use in your code
From your CMake script:
find_package(mrpt_path_planning REQUIRED)
target_link_libraries(YOUR_TARGET mpp::mrpt_path_planning)
Demo runs
path-planner-cli
Dump default planner parameters to a YAML file for inspection or customization:
build/bin/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), using a pre-built obstacle point cloud and an obstacle-proximity cost map:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5 45]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--costmap-obstacles share/costmap-obstacles.yaml
Plan a path with an R(2) goal (position only, heading-agnostic), printing the edge details of the found path and saving the interpolated trajectory to a CSV:
build/bin/path-planner-cli \
-s "[0.5 0 0]" \
-g "[4 2.5]" \
-c share/ptgs_holonomic_robot.ini \
--obstacles share/obstacles_01.txt \
--planner-parameters share/mvsim-demo-astar-planner-params.yaml \
--print-path-edges \
--save-interpolated-path path.csv
Plan a path for an Ackermann (car-like) vehicle, show the full explored search
tree, and animate the result. Note the goal is given as a position [x y] (R²,
heading-agnostic): with arc-based PTGs, arriving at a precise heading AND position
simultaneously is very constrained, so position-only goals are the natural choice
for non-holonomic vehicles:
File truncated at 100 lines see the full file