smac_planner_lattice_impl.hpp

// Copyright (c) 2021, Samsung Research America
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License. Reserved.
 
#ifndef NAV2_SMAC_PLANNER__SMAC_PLANNER_LATTICE_IMPL_HPP_
#define NAV2_SMAC_PLANNER__SMAC_PLANNER_LATTICE_IMPL_HPP_
 
#include <algorithm>
#include <cmath>
#include <limits>
#include <memory>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include "nav2_ros_common/node_utils.hpp"
#include "nav2_smac_planner/smac_planner_lattice.hpp"
#include "nav2_ros_common/tf2_factories.hpp"
 
// #define BENCHMARK_TESTING
 
namespace nav2_smac_planner
{
 
using namespace std::chrono;  // NOLINT
using rcl_interfaces::msg::ParameterType;
 
template<typename NodeT>
SmacPlannerLatticeT<NodeT>::SmacPlannerLatticeT()
: _a_star(nullptr),
  _collision_checker(nullptr, 1, nullptr),
  _smoother(nullptr),
  _costmap(nullptr)
{
}
 
template<typename NodeT>
SmacPlannerLatticeT<NodeT>::~SmacPlannerLatticeT()
{
  RCLCPP_INFO(
    _logger, "Destroying plugin %s of type SmacPlannerLattice",
    _name.c_str());
}
 
template<typename NodeT>
void SmacPlannerLatticeT<NodeT>::configure(
  const nav2::LifecycleNode::WeakPtr & parent,
  std::string name, nav2::TransformBuffer::SharedPtr/*tf*/,
  std::shared_ptr<nav2_costmap_2d::Costmap2DROS> costmap_ros)
{
  _node = parent;
  auto node = parent.lock();
  _logger = node->get_logger();
  _clock = node->get_clock();
  _costmap = costmap_ros->getCostmap();
  _costmap_ros = costmap_ros;
  _name = name;
  _global_frame = costmap_ros->getGlobalFrameID();
 
  RCLCPP_INFO(_logger, "Configuring %s of type SmacPlannerLattice", name.c_str());
 
  // General planner params
 
  _tolerance = static_cast<float>(node->declare_or_get_parameter(name + ".tolerance", 0.25));
  _allow_unknown = node->declare_or_get_parameter(name + ".allow_unknown", true);
  _max_iterations = node->declare_or_get_parameter(name + ".max_iterations", 1000000);
  _max_on_approach_iterations =
    node->declare_or_get_parameter(name + ".max_on_approach_iterations", 1000);
  _terminal_checking_interval =
    node->declare_or_get_parameter(name + ".terminal_checking_interval", 5000);
  bool smooth_path = node->declare_or_get_parameter(name + ".smooth_path", true);
 
  // Default to a well rounded model: 16 bin, 0.4m turning radius, ackermann model
  _search_info.lattice_filepath = node->declare_or_get_parameter(
    name + ".lattice_filepath",
    nav2::get_package_share_directory("nav2_smac_planner") +
    "/sample_primitives/5cm_resolution/0.5m_turning_radius/ackermann/output.json");
  _search_info.cache_obstacle_heuristic =
    node->declare_or_get_parameter(name + ".cache_obstacle_heuristic", false);
  _search_info.reverse_penalty =
    node->declare_or_get_parameter(name + ".reverse_penalty", 2.0);
  _search_info.change_penalty =
    node->declare_or_get_parameter(name + ".change_penalty", 0.05);
  _search_info.non_straight_penalty =
    node->declare_or_get_parameter(name + ".non_straight_penalty", 1.05);
  _search_info.cost_penalty =
    node->declare_or_get_parameter(name + ".cost_penalty", 2.0);
  _search_info.retrospective_penalty =
    node->declare_or_get_parameter(name + ".retrospective_penalty", 0.015);
  _search_info.rotation_penalty =
    node->declare_or_get_parameter(name + ".rotation_penalty", 5.0);
  _search_info.analytic_expansion_ratio =
    node->declare_or_get_parameter(name + ".analytic_expansion_ratio", 3.5);
  _search_info.analytic_expansion_max_cost =
    node->declare_or_get_parameter(name + ".analytic_expansion_max_cost", 200.0);
  _search_info.analytic_expansion_max_cost_override =
    node->declare_or_get_parameter(name + ".analytic_expansion_max_cost_override", false);
  _analytic_expansion_max_length_m =
    node->declare_or_get_parameter(name + ".analytic_expansion_max_length", 3.0);
  _search_info.use_quadratic_cost_penalty =
    node->declare_or_get_parameter(name + ".use_quadratic_cost_penalty", false);
  _search_info.downsample_obstacle_heuristic =
    node->declare_or_get_parameter(name + ".downsample_obstacle_heuristic", true);
 
  _max_planning_time = node->declare_or_get_parameter(name + ".max_planning_time", 5.0);
  _lookup_table_size = node->declare_or_get_parameter(name + ".lookup_table_size", 20.0);
  _search_info.allow_reverse_expansion =
    node->declare_or_get_parameter(name + ".allow_reverse_expansion", false);
  _debug_visualizations = node->declare_or_get_parameter(name + ".debug_visualizations", false);
 
  std::string goal_heading_type =
    node->declare_or_get_parameter(name + ".goal_heading_mode", std::string("DEFAULT"));
  _goal_heading_mode = fromStringToGH(goal_heading_type);
 
  _coarse_search_resolution =
    node->declare_or_get_parameter(name + ".coarse_search_resolution", 1);
 
  if (_goal_heading_mode == GoalHeadingMode::UNKNOWN) {
    std::string error_msg = "Unable to get GoalHeader type. Given '" + goal_heading_type + "' "
      "Valid options are DEFAULT, BIDIRECTIONAL, ALL_DIRECTION. ";
    throw nav2_core::PlannerException(error_msg);
  }
 
  _metadata = LatticeMotionTable::getLatticeMetadata(_search_info.lattice_filepath);
  _search_info.analytic_expansion_max_length =
    _analytic_expansion_max_length_m / _metadata.grid_resolution;
  _search_info.minimum_turning_radius =
    _metadata.min_turning_radius / (_metadata.grid_resolution);
  _motion_model = MotionModel::STATE_LATTICE;
 
  if (_metadata.motion_model == "omni" && _search_info.allow_reverse_expansion) {
    RCLCPP_WARN(
      _logger,
      "allow_reverse_expansion is not applicable for omnidirectional robots. Disabling.");
    _search_info.allow_reverse_expansion = false;
  }
 
  if (_max_on_approach_iterations <= 0) {
    RCLCPP_INFO(
      _logger, "On approach iteration selected as <= 0, "
      "disabling tolerance and on approach iterations.");
    _max_on_approach_iterations = std::numeric_limits<int>::max();
  }
 
  if (_max_iterations <= 0) {
    RCLCPP_INFO(
      _logger, "maximum iteration selected as <= 0, "
      "disabling maximum iterations.");
    _max_iterations = std::numeric_limits<int>::max();
  }
 
  if (_coarse_search_resolution <= 0) {
    RCLCPP_WARN(
      _logger, "coarse iteration resolution selected as <= 0, "
      "disabling coarse iteration resolution search for goal heading"
    );
    _coarse_search_resolution = 1;
  }
 
  if (_metadata.number_of_headings % _coarse_search_resolution != 0) {
    std::string error_msg = "coarse iteration should be an increment of"
      " the number of angular bins configured";
    throw nav2_core::PlannerException(error_msg);
  }
 
  float lookup_table_dim =
    static_cast<float>(_lookup_table_size) /
    static_cast<float>(_metadata.grid_resolution);
 
  // Make sure its a whole number
  lookup_table_dim = static_cast<float>(static_cast<int>(lookup_table_dim));
 
  // Make sure its an odd number
  if (static_cast<int>(lookup_table_dim) % 2 == 0) {
    RCLCPP_INFO(
      _logger,
      "Even sized heuristic lookup table size set %f, increasing size by 1 to make odd",
      lookup_table_dim);
    lookup_table_dim += 1.0;
  }
 
  // Initialize collision checker using 72 evenly sized bins instead of the lattice
  // heading angles. This is done so that we have precomputed angles every 5 degrees.
  // If we used the sparse lattice headings (usually 16), then when we attempt to collision
  // check for intermediary points of the primitives, we're forced to round to one of the 16
  // increments causing "wobbly" checks that could cause larger robots to virtually show collisions
  // in valid configurations. This approximation helps to bound orientation error for all checks
  // in exchange for slight inaccuracies in the collision headings in terminal search states.
  _collision_checker = GridCollisionChecker(_costmap_ros, 72u, node);
  _collision_checker.setFootprint(
    costmap_ros->getRobotFootprint(),
    costmap_ros->getUseRadius(),
    findCircumscribedCost(costmap_ros));
 
  // Initialize A* template
  _a_star = std::make_unique<AStarAlgorithm<NodeT>>(_motion_model, _search_info);
  _a_star->initialize(
    _allow_unknown,
    _max_iterations,
    _max_on_approach_iterations,
    _terminal_checking_interval,
    _max_planning_time,
    lookup_table_dim,
    _metadata.number_of_headings);
 
  // Initialize path smoother
  SmootherParams params;
  params.get(node, name);
  if (_metadata.motion_model == "omni") {
    params.holonomic_ = true;
  }
  if (smooth_path) {
    _smoother = std::make_unique<Smoother>(params);
    _smoother->initialize(_metadata.min_turning_radius);
  }
 
  _raw_plan_publisher = node->create_publisher<nav_msgs::msg::Path>("unsmoothed_plan");
 
  if (_debug_visualizations) {
    _expansions_publisher = node->create_publisher<geometry_msgs::msg::PoseArray>("expansions");
    _planned_footprints_publisher = node->create_publisher<visualization_msgs::msg::MarkerArray>(
      "planned_footprints");
    _smoothed_footprints_publisher =
      node->create_publisher<visualization_msgs::msg::MarkerArray>(
      "smoothed_footprints");
  }
 
  RCLCPP_INFO(
    _logger, "Configured plugin %s of type SmacPlannerLattice with "
    "maximum iterations %i, max on approach iterations %i, "
    "and %s. Tolerance %.2f. Using motion model: %s. State lattice file: %s.",
    _name.c_str(), _max_iterations, _max_on_approach_iterations,
    _allow_unknown ? "allowing unknown traversal" : "not allowing unknown traversal",
    _tolerance, toString(_motion_model).c_str(), _search_info.lattice_filepath.c_str());
}
 
template<typename NodeT>
void SmacPlannerLatticeT<NodeT>::activate()
{
  RCLCPP_INFO(
    _logger, "Activating plugin %s of type SmacPlannerLattice",
    _name.c_str());
  _raw_plan_publisher->on_activate();
  if (_debug_visualizations) {
    _expansions_publisher->on_activate();
    _planned_footprints_publisher->on_activate();
    _smoothed_footprints_publisher->on_activate();
  }
  auto node = _node.lock();
  // Add callback for dynamic parameters
  _post_set_params_handler = node->add_post_set_parameters_callback(
    std::bind(
      &SmacPlannerLatticeT<NodeT>::updateParametersCallback,
      this, std::placeholders::_1));
  _on_set_params_handler = node->add_on_set_parameters_callback(
    std::bind(
      &SmacPlannerLatticeT<NodeT>::validateParameterUpdatesCallback,
      this, std::placeholders::_1));
}
 
template<typename NodeT>
void SmacPlannerLatticeT<NodeT>::deactivate()
{
  RCLCPP_INFO(
    _logger, "Deactivating plugin %s of type SmacPlannerLattice",
    _name.c_str());
  _raw_plan_publisher->on_deactivate();
  if (_debug_visualizations) {
    _expansions_publisher->on_deactivate();
    _planned_footprints_publisher->on_deactivate();
    _smoothed_footprints_publisher->on_deactivate();
  }
  // shutdown dyn_param_handler
  auto node = _node.lock();
  if (_post_set_params_handler && node) {
    node->remove_post_set_parameters_callback(_post_set_params_handler.get());
  }
  _post_set_params_handler.reset();
  if (_on_set_params_handler && node) {
    node->remove_on_set_parameters_callback(_on_set_params_handler.get());
  }
  _on_set_params_handler.reset();
}
 
template<typename NodeT>
void SmacPlannerLatticeT<NodeT>::cleanup()
{
  RCLCPP_INFO(
    _logger, "Cleaning up plugin %s of type SmacPlannerLattice",
    _name.c_str());
  _a_star.reset();
  _smoother.reset();
  _raw_plan_publisher.reset();
  if (_debug_visualizations) {
    _expansions_publisher.reset();
    _planned_footprints_publisher.reset();
    _smoothed_footprints_publisher.reset();
  }
}
 
template<typename NodeT>
nav_msgs::msg::Path SmacPlannerLatticeT<NodeT>::createPlan(
  const geometry_msgs::msg::PoseStamped & start,
  const geometry_msgs::msg::PoseStamped & goal,
  const std::vector<geometry_msgs::msg::PoseStamped> & viapoints,
  std::function<bool()> cancel_checker)
{
  if (!viapoints.empty()) {
    RCLCPP_WARN(_logger, "Received %zu viapoints, but this planner ignores them",
      viapoints.size());
  }
 
  std::lock_guard<std::mutex> lock_reinit(_mutex);
  steady_clock::time_point a = steady_clock::now();
 
  std::unique_lock<nav2_costmap_2d::Costmap2D::mutex_t> lock(*(_costmap->getMutex()));
 
  if (std::abs(_costmap->getResolution() - _metadata.grid_resolution) > 1e-6) {
    throw nav2_core::PlannerException(
            "Costmap resolution " + std::to_string(_costmap->getResolution()) +
            " does not match lattice resolution " + std::to_string(_metadata.grid_resolution) +
            ". Use primitives generated for the actual costmap resolution.");
  }
 
  // Set collision checker and costmap information
  _collision_checker.setFootprint(
    _costmap_ros->getRobotFootprint(),
    _costmap_ros->getUseRadius(),
    findCircumscribedCost(_costmap_ros));
  _a_star->setCollisionChecker(&_collision_checker);
 
  // Set starting point, in A* bin search coordinates
  float mx_start, my_start, mx_goal, my_goal;
  if (!_costmap->worldToMapContinuous(
      start.pose.position.x,
      start.pose.position.y,
      mx_start,
      my_start))
  {
    throw nav2_core::StartOutsideMapBounds(
            "Start Coordinates of(" + std::to_string(start.pose.position.x) + ", " +
            std::to_string(start.pose.position.y) + ") was outside bounds");
  }
  unsigned int start_bin =
    _a_star->getContext()->motion_table.getClosestAngularBin(tf2::getYaw(start.pose.orientation));
  _a_star->setStart(mx_start, my_start, start_bin);
 
  // Set goal point, in A* bin search coordinates
  if (!_costmap->worldToMapContinuous(
      goal.pose.position.x,
      goal.pose.position.y,
      mx_goal,
      my_goal))
  {
    throw nav2_core::GoalOutsideMapBounds(
            "Goal Coordinates of(" + std::to_string(goal.pose.position.x) + ", " +
            std::to_string(goal.pose.position.y) + ") was outside bounds");
  }
  unsigned int goal_bin =
    _a_star->getContext()->motion_table.getClosestAngularBin(tf2::getYaw(goal.pose.orientation));
  _a_star->setGoal(
    mx_goal, my_goal, goal_bin,
    _goal_heading_mode, _coarse_search_resolution);
 
  // Setup message
  nav_msgs::msg::Path plan;
  plan.header.stamp = _clock->now();
  plan.header.frame_id = _global_frame;
  geometry_msgs::msg::PoseStamped pose;
  pose.header = plan.header;
  pose.pose.position.z = 0.0;
  pose.pose.orientation.x = 0.0;
  pose.pose.orientation.y = 0.0;
  pose.pose.orientation.z = 0.0;
  pose.pose.orientation.w = 1.0;
 
  // Corner case of start and goal being on the same cell
  if (std::floor(mx_start) == std::floor(mx_goal) &&
    std::floor(my_start) == std::floor(my_goal) &&
    start_bin == goal_bin)
  {
    pose.pose = start.pose;
    pose.pose.orientation = goal.pose.orientation;
    plan.poses.push_back(pose);
 
    // Publish raw path for debug
    if (_raw_plan_publisher->get_subscription_count() > 0) {
      auto msg = std::make_unique<nav_msgs::msg::Path>(plan);
      _raw_plan_publisher->publish(std::move(msg));
    }
 
    return plan;
  }
 
  // Compute plan
  typename NodeT::CoordinateVector path;
  int num_iterations = 0;
  std::string error;
  std::unique_ptr<std::vector<std::tuple<float, float, float>>> expansions = nullptr;
  if (_debug_visualizations) {
    expansions = std::make_unique<std::vector<std::tuple<float, float, float>>>();
  }
 
  // Note: All exceptions thrown are handled by the planner server and returned to the action
  if (!_a_star->createPath(
      path, num_iterations,
      _tolerance / static_cast<float>(_costmap->getResolution()), cancel_checker, expansions.get()))
  {
    if (_debug_visualizations) {
      auto now = _clock->now();
      auto msg = std::make_unique<geometry_msgs::msg::PoseArray>();
      geometry_msgs::msg::Pose msg_pose;
      msg->header.stamp = now;
      msg->header.frame_id = _global_frame;
      for (auto & e : *expansions) {
        msg_pose.position.x = std::get<0>(e);
        msg_pose.position.y = std::get<1>(e);
        msg_pose.orientation = getWorldOrientation(std::get<2>(e));
        msg->poses.push_back(msg_pose);
      }
      _expansions_publisher->publish(std::move(msg));
    }
 
    // Note: If the start is blocked only one iteration will occur before failure
    if (num_iterations == 1) {
      throw nav2_core::StartOccupied("Start occupied");
    }
 
    if (num_iterations < _a_star->getMaxIterations()) {
      throw nav2_core::NoValidPathCouldBeFound("no valid path found");
    } else {
      throw nav2_core::PlannerTimedOut("exceeded maximum iterations");
    }
  }
 
  // Convert to world coordinates
  plan.poses.reserve(path.size());
  geometry_msgs::msg::PoseStamped last_pose = pose;
  for (int i = path.size() - 1; i >= 0; --i) {
    pose.pose = getWorldCoords(path[i].x, path[i].y, _costmap);
    pose.pose.orientation = getWorldOrientation(path[i].theta);
    if (fabs(pose.pose.position.x - last_pose.pose.position.x) < 1e-4 &&
      fabs(pose.pose.position.y - last_pose.pose.position.y) < 1e-4 &&
      fabs(tf2::getYaw(pose.pose.orientation) - tf2::getYaw(last_pose.pose.orientation)) < 1e-4)
    {
      RCLCPP_DEBUG(
        _logger,
        "Removed a path from the path due to replication. "
        "Make sure your minimum control set does not contain duplicate values!");
      continue;
    }
    last_pose = pose;
    plan.poses.push_back(pose);
  }
 
  // Publish raw path for debug
  if (_raw_plan_publisher->get_subscription_count() > 0) {
    auto msg = std::make_unique<nav_msgs::msg::Path>(plan);
    _raw_plan_publisher->publish(std::move(msg));
  }
 
  if (_debug_visualizations) {
    auto now = _clock->now();
    // Publish expansions for debug
    auto msg = std::make_unique<geometry_msgs::msg::PoseArray>();
    geometry_msgs::msg::Pose msg_pose;
    msg->header.stamp = now;
    msg->header.frame_id = _global_frame;
    for (auto & e : *expansions) {
      msg_pose.position.x = std::get<0>(e);
      msg_pose.position.y = std::get<1>(e);
      msg_pose.orientation = getWorldOrientation(std::get<2>(e));
      msg->poses.push_back(msg_pose);
    }
    _expansions_publisher->publish(std::move(msg));
 
    if (_planned_footprints_publisher->get_subscription_count() > 0) {
      // Clear all markers first
      auto marker_array = std::make_unique<visualization_msgs::msg::MarkerArray>();
      visualization_msgs::msg::Marker clear_all_marker;
      clear_all_marker.action = visualization_msgs::msg::Marker::DELETEALL;
      marker_array->markers.push_back(clear_all_marker);
      _planned_footprints_publisher->publish(std::move(marker_array));
 
      // Publish smoothed footprints for debug
      marker_array = std::make_unique<visualization_msgs::msg::MarkerArray>();
      for (size_t i = 0; i < plan.poses.size(); i++) {
        const std::vector<geometry_msgs::msg::Point> edge =
          transformFootprintToEdges(plan.poses[i].pose, _costmap_ros->getRobotFootprint());
        marker_array->markers.push_back(createMarker(edge, i, _global_frame, now));
      }
      _planned_footprints_publisher->publish(std::move(marker_array));
    }
  }
 
  // Find how much time we have left to do smoothing
  steady_clock::time_point b = steady_clock::now();
  duration<double> time_span = duration_cast<duration<double>>(b - a);
  double time_remaining = _max_planning_time - static_cast<double>(time_span.count());
 
#ifdef BENCHMARK_TESTING
  std::cout << "It took " << time_span.count() * 1000 <<
    " milliseconds with " << num_iterations << " iterations." << std::endl;
#endif
 
  // Smooth plan
  if (_smoother && num_iterations > 1) {
    _smoother->smooth(
      plan,
      _costmap,
      time_remaining,
      _costmap_ros->getUseRadius() ? std::vector<geometry_msgs::msg::Point>() :
      _costmap_ros->getRobotFootprint());
  }
 
#ifdef BENCHMARK_TESTING
  steady_clock::time_point c = steady_clock::now();
  duration<double> time_span2 = duration_cast<duration<double>>(c - b);
  std::cout << "It took " << time_span2.count() * 1000 <<
    " milliseconds to smooth path." << std::endl;
#endif
 
  if (_debug_visualizations) {
    if (_smoothed_footprints_publisher->get_subscription_count() > 0) {
      // Clear all markers first
      auto marker_array = std::make_unique<visualization_msgs::msg::MarkerArray>();
      visualization_msgs::msg::Marker clear_all_marker;
      clear_all_marker.action = visualization_msgs::msg::Marker::DELETEALL;
      marker_array->markers.push_back(clear_all_marker);
      _smoothed_footprints_publisher->publish(std::move(marker_array));
 
      // Publish smoothed footprints for debug
      marker_array = std::make_unique<visualization_msgs::msg::MarkerArray>();
      auto now = _clock->now();
      for (size_t i = 0; i < plan.poses.size(); i++) {
        const std::vector<geometry_msgs::msg::Point> edge =
          transformFootprintToEdges(plan.poses[i].pose, _costmap_ros->getRobotFootprint());
        marker_array->markers.push_back(createMarker(edge, i, _global_frame, now));
      }
      _smoothed_footprints_publisher->publish(std::move(marker_array));
    }
  }
 
  return plan;
}
 
template<typename NodeT>
rcl_interfaces::msg::SetParametersResult
SmacPlannerLatticeT<NodeT>::validateParameterUpdatesCallback(
  const std::vector<rclcpp::Parameter> & parameters)
{
  rcl_interfaces::msg::SetParametersResult result;
  result.successful = true;
  for (const auto & parameter : parameters) {
    const auto & param_type = parameter.get_type();
    const auto & param_name = parameter.get_name();
    if (param_name.find(_name + ".") != 0) {
      continue;
    }
    if (param_type == ParameterType::PARAMETER_DOUBLE) {
      if (parameter.as_double() < 0.0) {
        RCLCPP_WARN(
        _logger, "The value of parameter '%s' is incorrectly set to %f, "
        "it should be >=0. Ignoring parameter update.",
        param_name.c_str(), parameter.as_double());
        result.successful = false;
      }
    } else if (param_type == ParameterType::PARAMETER_INTEGER) {
      if (param_name == _name + ".coarse_search_resolution" && _metadata.number_of_headings %
        parameter.as_int() != 0)
      {
        RCLCPP_WARN(
          _logger,
          "coarse iteration should be an increment of the number"
          " of angular bins configured. Ignoring parameter update!"
        );
        result.successful = false;
      } else if (parameter.as_int() <= 0 && (param_name != _name + ".max_iterations" && // NOLINT
        param_name != _name + ".max_on_approach_iterations"))
      {
        RCLCPP_WARN(
        _logger, "The value of parameter '%s' is incorrectly set to %ld, "
        "it should be >0. Ignoring parameter update.",
        param_name.c_str(), parameter.as_int());
        result.successful = false;
      }
    } else if (param_type == ParameterType::PARAMETER_STRING) {
      if (param_name == _name + ".lattice_filepath") {
        LatticeMetadata metadata =
          LatticeMotionTable::getLatticeMetadata(parameter.as_string());
        if (metadata.number_of_headings % _coarse_search_resolution != 0) {
          RCLCPP_WARN(
            _logger,
            "coarse iteration should be an increment of the number "
            "of angular bins configured. Ignoring parameter update!"
          );
          result.successful = false;
        }
      } else if (param_name == _name + ".goal_heading_mode") {
        GoalHeadingMode goal_heading_mode = fromStringToGH(parameter.as_string());
        if (goal_heading_mode == GoalHeadingMode::UNKNOWN) {
          RCLCPP_WARN(
            _logger,
            "Unable to get GoalHeader type. Given '%s' Valid options are "
            "DEFAULT, BIDIRECTIONAL, ALL_DIRECTION. Ignoring parameter update!",
            parameter.as_string().c_str());
          result.successful = false;
        }
      }
    }
  }
  return result;
}
 
template<typename NodeT>
void
SmacPlannerLatticeT<NodeT>::updateParametersCallback(
  const std::vector<rclcpp::Parameter> & parameters)
{
  std::lock_guard<std::mutex> lock_reinit(_mutex);
 
  bool reinit_a_star = false;
  bool reinit_lookup_table = false;
  bool reinit_smoother = false;
 
  for (auto parameter : parameters) {
    const auto & param_type = parameter.get_type();
    const auto & param_name = parameter.get_name();
    if (param_name.find(_name + ".") != 0) {
      continue;
    }
    if (param_type == ParameterType::PARAMETER_DOUBLE) {
      if (param_name == _name + ".max_planning_time") {
        reinit_a_star = true;
        _max_planning_time = parameter.as_double();
      } else if (param_name == _name + ".tolerance") {
        _tolerance = static_cast<float>(parameter.as_double());
      } else if (param_name == _name + ".lookup_table_size") {
        reinit_a_star = true;
        reinit_lookup_table = true;
        _lookup_table_size = parameter.as_double();
      } else if (param_name == _name + ".reverse_penalty") {
        reinit_a_star = true;
        _search_info.reverse_penalty = static_cast<float>(parameter.as_double());
      } else if (param_name == _name + ".change_penalty") {
        reinit_a_star = true;
        _search_info.change_penalty = static_cast<float>(parameter.as_double());
      } else if (param_name == _name + ".non_straight_penalty") {
        reinit_a_star = true;
        _search_info.non_straight_penalty = static_cast<float>(parameter.as_double());
      } else if (param_name == _name + ".cost_penalty") {
        reinit_a_star = true;
        _search_info.cost_penalty = static_cast<float>(parameter.as_double());
      } else if (param_name == _name + ".rotation_penalty") {
        reinit_a_star = true;
        _search_info.rotation_penalty = static_cast<float>(parameter.as_double());
      } else if (param_name == _name + ".analytic_expansion_ratio") {
        reinit_a_star = true;
        _search_info.analytic_expansion_ratio = static_cast<float>(parameter.as_double());
      } else if (param_name == _name + ".analytic_expansion_max_length") {
        reinit_a_star = true;
        _analytic_expansion_max_length_m = parameter.as_double();
      } else if (param_name == _name + ".analytic_expansion_max_cost") {
        reinit_a_star = true;
        _search_info.analytic_expansion_max_cost = static_cast<float>(parameter.as_double());
      }
    } else if (param_type == ParameterType::PARAMETER_BOOL) {
      if (param_name == _name + ".allow_unknown") {
        reinit_a_star = true;
        _allow_unknown = parameter.as_bool();
      } else if (param_name == _name + ".cache_obstacle_heuristic") {
        reinit_a_star = true;
        _search_info.cache_obstacle_heuristic = parameter.as_bool();
      } else if (param_name == _name + ".allow_reverse_expansion") {
        reinit_a_star = true;
        reinit_lookup_table = true;
        _search_info.allow_reverse_expansion = parameter.as_bool();
      } else if (param_name == _name + ".smooth_path") {
        if (parameter.as_bool()) {
          reinit_smoother = true;
        } else {
          _smoother.reset();
        }
      } else if (param_name == _name + ".analytic_expansion_max_cost_override") {
        _search_info.analytic_expansion_max_cost_override = parameter.as_bool();
        reinit_a_star = true;
      }
    } else if (param_type == ParameterType::PARAMETER_INTEGER) {
      if (param_name == _name + ".max_iterations") {
        reinit_a_star = true;
        _max_iterations = parameter.as_int();
        if (_max_iterations <= 0) {
          RCLCPP_INFO(
            _logger, "maximum iteration selected as <= 0, "
            "disabling maximum iterations.");
          _max_iterations = std::numeric_limits<int>::max();
        }
      } else if (param_name == _name + ".max_on_approach_iterations") {
        reinit_a_star = true;
        _max_on_approach_iterations = parameter.as_int();
        if (_max_on_approach_iterations <= 0) {
          RCLCPP_INFO(
            _logger, "On approach iteration selected as <= 0, "
            "disabling tolerance and on approach iterations.");
          _max_on_approach_iterations = std::numeric_limits<int>::max();
        }
      } else if (param_name == _name + ".terminal_checking_interval") {
        reinit_a_star = true;
        _terminal_checking_interval = parameter.as_int();
      } else if (param_name == _name + ".coarse_search_resolution") {
        _coarse_search_resolution = parameter.as_int();
      }
    } else if (param_type == ParameterType::PARAMETER_STRING) {
      if (param_name == _name + ".lattice_filepath") {
        reinit_a_star = true;
        reinit_lookup_table = true;
        if (_smoother) {
          reinit_smoother = true;
        }
        _search_info.lattice_filepath = parameter.as_string();
        _metadata = LatticeMotionTable::getLatticeMetadata(_search_info.lattice_filepath);
        _search_info.minimum_turning_radius =
          _metadata.min_turning_radius / (_metadata.grid_resolution);
      } else if (param_name == _name + ".goal_heading_mode") {
        std::string goal_heading_type = parameter.as_string();
        RCLCPP_INFO(
          _logger,
          "GoalHeadingMode type set to '%s'.",
          goal_heading_type.c_str());
        _goal_heading_mode = fromStringToGH(goal_heading_type);
      }
    }
  }
 
  // Re-init if needed with mutex lock (to avoid re-init while creating a plan)
  if (reinit_a_star || reinit_smoother) {
    // Convert using the fixed resolution of the lattice primitives.
    _search_info.analytic_expansion_max_length =
      _analytic_expansion_max_length_m / _metadata.grid_resolution;
    _search_info.minimum_turning_radius =
      _metadata.min_turning_radius / (_metadata.grid_resolution);
    float lookup_table_dim =
      static_cast<float>(_lookup_table_size) /
      static_cast<float>(_metadata.grid_resolution);
 
    // Make sure its a whole number
    lookup_table_dim = static_cast<float>(static_cast<int>(lookup_table_dim));
 
    // Make sure its an odd number
    if (static_cast<int>(lookup_table_dim) % 2 == 0) {
      RCLCPP_INFO(
        _logger,
        "Even sized heuristic lookup table size set %f, increasing size by 1 to make odd",
        lookup_table_dim);
      lookup_table_dim += 1.0;
    }
 
    // Re-Initialize smoother
    if (reinit_smoother) {
      auto node = _node.lock();
      SmootherParams params;
      params.get(node, _name);
      if (_metadata.motion_model == "omni") {
        params.holonomic_ = true;
      }
      _smoother = std::make_unique<Smoother>(params);
      _smoother->initialize(_metadata.min_turning_radius);
    }
 
    // Re-Initialize A* template
    if (reinit_a_star) {
      if (_metadata.motion_model == "omni" && _search_info.allow_reverse_expansion) {
        RCLCPP_WARN(
          _logger,
          "allow_reverse_expansion is not applicable for omnidirectional robots. Disabling.");
        _search_info.allow_reverse_expansion = false;
      }
      if (reinit_lookup_table) {
        _a_star = std::make_unique<AStarAlgorithm<NodeT>>(_motion_model, _search_info);
      } else {
        _a_star->setSearchInfo(_search_info);
      }
      _a_star->initialize(
        _allow_unknown,
        _max_iterations,
        _max_on_approach_iterations,
        _terminal_checking_interval,
        _max_planning_time,
        lookup_table_dim,
        _metadata.number_of_headings);
    }
  }
}
 
}  // namespace nav2_smac_planner
 
#endif  // NAV2_SMAC_PLANNER__SMAC_PLANNER_LATTICE_IMPL_HPP_