Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version jazzy
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version kilted
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version lyrical
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange

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

Package Summary

Version 0.5.0
License Apache-2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Description
Checkout URI https://github.com/EasyNavigation/easynav_plugins.git
VCS Type git
VCS Version humble
Last Updated 2026-10-09
Dev Status DEVELOPED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Easy Navigation: navmap planner package.

Maintainers

  • Francisco Martín Rico

Authors

No additional authors.

easynav_navmap_planner

ROS 2: humble ROS 2: jazzy ROS 2: kilted ROS 2: rolling

Description

A* path planner operating over a NavMap triangular mesh.
The planner computes the minimum-cost path between the robot and the goal, taking into account both the geometric distance between triangles and the cost values stored in a selected NavMap layer (typically "inflated_obstacles").

Instead of simply avoiding non-free NavCels, the planner integrates their cost values (0–255) into the path evaluation. Cells marked as LETHAL_OBSTACLE, NO_INFORMATION or inscribed (INSCRIBED_INFLATED_OBSTACLE) are non-traversable (inscribed ones only near the start, so a robot inside that band can leave it), while inflated cells are allowed but penalized proportionally to their cost.

The search moves between NavCels that share a vertex, not only an edge, so no direction is favored by how the mesh is split; a move through a shared vertex is only taken when every NavCel around that vertex is traversable, so the path never slips between two obstacles that touch at a corner. Then the path is shortened by line of sight: from each waypoint it goes straight to the farthest one whose segment crosses only traversable NavCels no costlier than the waypoints it replaces, and the result is resampled at the NavCel spacing on the surface. The path ends exactly at the goal.

This enables smoother and safer trajectories that still respect proximity constraints imposed by obstacle inflation.

Cost model

For two neighboring NavCels u and v, the edge cost is computed as:

[ \text{cost}(u,v) = d(u,v) \times \left(\text{cost_factor} + \text{inflation_penalty} \times \frac{c(v)}{253}\right) ]

where d(u,v) is the Euclidean distance between triangle centroids,
and c(v) is the cost value of cell v.
This formulation ensures that:

  • cells near obstacles (high cost) are traversed only if geometrically necessary,
  • lethal (254) and unknown (255) cells are not traversable.

Authors and Maintainers

  • Authors: Intelligent Robotics Lab
  • Maintainers: Francisco Martín Rico fmrico@gmail.com

Supported ROS 2 Distributions

Distribution Status
humble humble
jazzy jazzy
kilted kilted
lyrical lyrical
rolling rolling

Plugin (pluginlib)

  • Plugin Name: easynav_navmap_planner/AStarPlanner
  • Type: easynav::navmap::AStarPlanner
  • Base Class: easynav::PlannerMethodBase
  • Library: easynav_navmap_planner
  • Description: A* path planner over a NavMap triangular mesh using per-cell costs to compute the shortest safe path.

Parameters

All parameters are declared under the plugin namespace, i.e.
/<node_fqn>/easynav_navmap_planner/AStarPlanner/...

Name Type Default Description
<plugin>.cost_factor double 2.0 Multiplicative weight for geometric distance; values > 1 increase the relative importance of distance.
<plugin>.cost_weight double 5.0 Weight of the cell cost (inflation) against the path length; higher values keep paths farther from obstacles.
<plugin>.continuous_replan bool true If true, recomputes the path whenever NavState updates; if false, plans once per goal.

Note: The planner internally uses hardcoded values for layer_name (prefers "inflated_obstacles", fallback to "obstacles"), cost_axial, and cost_diagonal. These are not runtime-configurable parameters.

Interfaces (Topics and Services)

Publications

| Direction | Topic | Type | Purpose | QoS | |—|—|—|—|—| | Publisher | <node_fqn>/<plugin>/path | nav_msgs/msg/Path | Publishes the computed A* path. | depth=10 |

This plugin does not create subscriptions or services directly; it retrieves all inputs from NavState.

| Key | Type | Access | Description | |—|—|—|—| | goals | nav_msgs::msg::Goals | Read | Target pose(s) for path planning. | | robot_pose | nav_msgs::msg::Odometry | Read | Current robot pose (start position). | | map.navmap | ::navmap::NavMap | Read | NavMap containing geometry and cost layer. The planner reads costs from the layer specified in <plugin>.layer (default: "inflated_obstacles"). If that layer does not exist, it automatically falls back to "obstacles". | | path | nav_msgs::msg::Path | Write | Output path, computed as the lowest-cost route. |

TF Frames

The planner assumes frame consistency between NavMap, robot pose, and goals. No TF lookups are performed internally.

License

Apache-2.0

CHANGELOG

Changelog for package easynav_navmap_planner

0.5.0 (2026-10-08)

  • Runtime reconfiguration
  • Planners never keep a stale path
  • The path ends at the goal, inscribed cells are not crossed, and cost_weight balances cost against length
  • A* over NavCels that share a vertex (no direction favored by the mesh) and line-of-sight shortcut of the path
  • Builds on Humble, Jazzy, Kilted, Lyrical and Rolling
  • Contributors: Francisco Martín Rico

0.4.2 (2026-07-26)

  • Complete deps
  • GPLv3 -> Apache 2.0
  • Improve navstate print including the time
  • Remove C++20/C++23 features and update to new MethodBase interface
  • Merge branch 'set_robot_frame' into frames-fix-pr-40
  • TFInfo in RTTFBuffer
  • Refactor to use TFInfo
  • Optimize execution
  • Cleanup unused headers
  • Update sheets
  • Path planner aware of obstacles and inflation
  • A Star uses obstacle layer
  • Contributors: Francisco Martín Rico, Francisco Miguel Moreno, Juan S. Cely, Juan S. Cely G., Miguel, migueldm

0.0.2 (2025-10-12)

  • Reorganization initial
  • Contributors: Francisco Martín Rico

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged easynav_navmap_planner at Robotics Stack Exchange