Merge pull request ros-navigation#12 from botsandus/AUTO-645_path_angle_fix

AUTO-645 Fix Path Angle Critics for bi-directionality

Author: doisyg

nav2_controller/CMakeLists.txt

@@ -50,6 +50,10 @@ set(dependencies
 add_library(simple_progress_checker SHARED plugins/simple_progress_checker.cpp)
 ament_target_dependencies(simple_progress_checker ${dependencies})
 
+add_library(rotation_progress_checker SHARED plugins/rotation_progress_checker.cpp)
+target_link_libraries(rotation_progress_checker simple_progress_checker)
+ament_target_dependencies(rotation_progress_checker ${dependencies})
+
 add_library(simple_goal_checker SHARED plugins/simple_goal_checker.cpp)
 ament_target_dependencies(simple_goal_checker ${dependencies})
 
@@ -79,7 +83,7 @@ target_link_libraries(${executable_name} ${library_name})
 
 rclcpp_components_register_nodes(${library_name} "nav2_controller::ControllerServer")
 
-install(TARGETS simple_progress_checker simple_goal_checker stopped_goal_checker ${library_name}
+install(TARGETS simple_progress_checker rotation_progress_checker simple_goal_checker stopped_goal_checker ${library_name}
   ARCHIVE DESTINATION lib
   LIBRARY DESTINATION lib
   RUNTIME DESTINATION bin
@@ -102,6 +106,7 @@ endif()
 
 ament_export_include_directories(include)
 ament_export_libraries(simple_progress_checker
+  rotation_progress_checker
   simple_goal_checker
   stopped_goal_checker
   ${library_name})

nav2_controller/include/nav2_controller/plugins/rotation_progress_checker.hpp

@@ -0,0 +1,68 @@
+// Copyright (c) 2023 Dexory
+//
+// 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.
+
+#ifndef NAV2_CONTROLLER__PLUGINS__ROTATION_PROGRESS_CHECKER_HPP_
+#define NAV2_CONTROLLER__PLUGINS__ROTATION_PROGRESS_CHECKER_HPP_
+
+#include <string>
+#include <vector>
+#include "rclcpp/rclcpp.hpp"
+#include "nav2_controller/plugins/simple_progress_checker.hpp"
+#include "rclcpp_lifecycle/lifecycle_node.hpp"
+#include "nav2_core/progress_checker.hpp"
+#include "geometry_msgs/msg/pose_stamped.hpp"
+#include "geometry_msgs/msg/pose2_d.hpp"
+
+namespace nav2_controller
+{
+/**
+* @class RotationProgressChecker
+* @brief This plugin is used to check the position and the angle of the robot to make sure
+* that it is actually progressing or rotating towards a goal.
+*/
+
+class RotationProgressChecker : public SimpleProgressChecker
+{
+public:
+  void initialize(
+    const rclcpp_lifecycle::LifecycleNode::WeakPtr & parent,
+    const std::string & plugin_name) override;
+  bool check(geometry_msgs::msg::PoseStamped & current_pose) override;
+
+protected:
+  /**
+   * @brief Calculates robots movement from baseline pose
+   * @param pose Current pose of the robot
+   * @return true, if movement is greater than radius_, or false
+   */
+  bool is_robot_moved_enough(const geometry_msgs::msg::Pose2D & pose);
+
+  static double pose_angle_distance(const geometry_msgs::msg::Pose2D &, const geometry_msgs::msg::Pose2D &);
+
+  double required_movement_angle_;
+
+  // Dynamic parameters handler
+  rclcpp::node_interfaces::OnSetParametersCallbackHandle::SharedPtr dyn_params_handler_;
+  std::string plugin_name_;
+
+  /**
+   * @brief Callback executed when a paramter change is detected
+   * @param parameters list of changed parameters
+   */
+  rcl_interfaces::msg::SetParametersResult
+  dynamicParametersCallback(std::vector<rclcpp::Parameter> parameters);
+};
+}  // namespace nav2_controller
+
+#endif  // NAV2_CONTROLLER__PLUGINS__ROTATION_PROGRESS_CHECKER_HPP_

nav2_controller/include/nav2_controller/plugins/simple_progress_checker.hpp

@@ -53,6 +53,8 @@ class SimpleProgressChecker : public nav2_core::ProgressChecker
    */
   void reset_baseline_pose(const geometry_msgs::msg::Pose2D & pose);
 
+  static double pose_distance(const geometry_msgs::msg::Pose2D &, const geometry_msgs::msg::Pose2D &);
+
   rclcpp::Clock::SharedPtr clock_;
 
   double radius_;

nav2_controller/plugins.xml

@@ -4,6 +4,11 @@
       <description>Checks if distance between current and previous pose is above a threshold</description>
     </class>
   </library>
+  <library path="rotation_progress_checker">
+    <class type="nav2_controller::RotationProgressChecker" base_class_type="nav2_core::ProgressChecker">
+      <description>Checks if distance and angle between current and previous pose is above a threshold</description>
+    </class>
+  </library>
   <library path="simple_goal_checker">
     <class type="nav2_controller::SimpleGoalChecker" base_class_type="nav2_core::GoalChecker">
       <description>Checks if current pose is within goal window for x,y and yaw</description>

nav2_controller/plugins/rotation_progress_checker.cpp

@@ -0,0 +1,97 @@
+// Copyright (c) 2023 Dexory
+//
+// 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.
+
+#include "nav2_controller/plugins/rotation_progress_checker.hpp"
+#include <cmath>
+#include <string>
+#include <memory>
+#include <vector>
+#include "angles/angles.h"
+#include "nav_2d_utils/conversions.hpp"
+#include "geometry_msgs/msg/pose_stamped.hpp"
+#include "geometry_msgs/msg/pose2_d.hpp"
+#include "nav2_util/node_utils.hpp"
+#include "pluginlib/class_list_macros.hpp"
+
+using rcl_interfaces::msg::ParameterType;
+using std::placeholders::_1;
+
+namespace nav2_controller
+{
+
+void RotationProgressChecker::initialize(
+  const rclcpp_lifecycle::LifecycleNode::WeakPtr & parent,
+  const std::string & plugin_name)
+{
+  plugin_name_ = plugin_name;
+  SimpleProgressChecker::initialize(parent, plugin_name);
+  auto node = parent.lock();
+
+  nav2_util::declare_parameter_if_not_declared(
+    node, plugin_name + ".required_movement_angle", rclcpp::ParameterValue(0.5));
+  node->get_parameter_or(plugin_name + ".required_movement_angle", required_movement_angle_, 0.5);
+
+  // Add callback for dynamic parameters
+  dyn_params_handler_ = node->add_on_set_parameters_callback(
+    std::bind(&RotationProgressChecker::dynamicParametersCallback, this, _1));
+}
+
+bool RotationProgressChecker::check(geometry_msgs::msg::PoseStamped & current_pose)
+{
+  // relies on short circuit evaluation to not call is_robot_moved_enough if
+  // baseline_pose is not set.
+  geometry_msgs::msg::Pose2D current_pose2d;
+  current_pose2d = nav_2d_utils::poseToPose2D(current_pose.pose);
+
+  if ((!baseline_pose_set_) || (RotationProgressChecker::is_robot_moved_enough(current_pose2d))) {
+    reset_baseline_pose(current_pose2d);
+    return true;
+  }
+  return !((clock_->now() - baseline_time_) > time_allowance_);
+}
+
+bool RotationProgressChecker::is_robot_moved_enough(const geometry_msgs::msg::Pose2D & pose)
+{
+  return pose_distance(pose, baseline_pose_) > radius_ ||
+         pose_angle_distance(pose, baseline_pose_) > required_movement_angle_;
+}
+
+double RotationProgressChecker::pose_angle_distance(
+  const geometry_msgs::msg::Pose2D & pose1,
+  const geometry_msgs::msg::Pose2D & pose2)
+{
+  return abs(angles::shortest_angular_distance(pose1.theta,pose2.theta));
+}
+
+rcl_interfaces::msg::SetParametersResult
+RotationProgressChecker::dynamicParametersCallback(std::vector<rclcpp::Parameter> parameters)
+{
+  rcl_interfaces::msg::SetParametersResult result;
+  for (auto parameter : parameters) {
+    const auto & type = parameter.get_type();
+    const auto & name = parameter.get_name();
+
+    if (type == ParameterType::PARAMETER_DOUBLE) {
+      if (name == plugin_name_ + ".required_movement_angle") {
+        required_movement_angle_ = parameter.as_double();
+      }
+    }
+  }
+  result.successful = true;
+  return result;
+}
+
+}  // namespace nav2_controller
+
+PLUGINLIB_EXPORT_CLASS(nav2_controller::RotationProgressChecker, nav2_core::ProgressChecker)

nav2_controller/plugins/simple_progress_checker.cpp

@@ -28,8 +28,6 @@ using std::placeholders::_1;
 
 namespace nav2_controller
 {
-static double pose_distance(const geometry_msgs::msg::Pose2D &, const geometry_msgs::msg::Pose2D &);
-
 void SimpleProgressChecker::initialize(
   const rclcpp_lifecycle::LifecycleNode::WeakPtr & parent,
   const std::string & plugin_name)
@@ -85,7 +83,7 @@ bool SimpleProgressChecker::is_robot_moved_enough(const geometry_msgs::msg::Pose
   return pose_distance(pose, baseline_pose_) > radius_;
 }
 
-static double pose_distance(
+double SimpleProgressChecker::pose_distance(
   const geometry_msgs::msg::Pose2D & pose1,
   const geometry_msgs::msg::Pose2D & pose2)
 {

nav2_mppi_controller/include/nav2_mppi_controller/tools/utils.hpp

@@ -419,13 +419,20 @@ inline void setPathCostsIfNotSet(
  * @param point_y Point to find angle relative to Y axis
  * @return Angle between two points
  */
-inline double posePointAngle(const geometry_msgs::msg::Pose & pose, double point_x, double point_y)
+inline double posePointAngle(
+  const geometry_msgs::msg::Pose & pose, double point_x, double point_y,
+  double point_yaw)
 {
   double pose_x = pose.position.x;
   double pose_y = pose.position.y;
   double pose_yaw = tf2::getYaw(pose.orientation);
 
   double yaw = atan2(point_y - pose_y, point_x - pose_x);
+
+  if (abs(angles::shortest_angular_distance(yaw, point_yaw)) > M_PI_2) {
+    yaw = angles::normalize_angle(yaw + M_PI);
+  }
+
   return abs(angles::shortest_angular_distance(yaw, pose_yaw));
 }
 

nav2_mppi_controller/src/critics/path_angle_critic.cpp

@@ -57,16 +57,30 @@ void PathAngleCritic::score(CriticData & data)
 
   const float goal_x = xt::view(data.path.x, offseted_idx);
   const float goal_y = xt::view(data.path.y, offseted_idx);
+  const float goal_yaw = xt::view(data.path.yaws, offseted_idx);
 
-  if (utils::posePointAngle(data.state.pose.pose, goal_x, goal_y) < max_angle_to_furthest_) {
+  if (utils::posePointAngle(
+      data.state.pose.pose, goal_x, goal_y,
+      goal_yaw) < max_angle_to_furthest_)
+  {
     return;
   }
 
   const auto yaws_between_points = xt::atan2(
     goal_y - data.trajectories.y,
     goal_x - data.trajectories.x);
+
+  const auto yaws_between_points_corrected = xt::eval(
+    xt::where(
+      xt::abs(utils::shortest_angular_distance(yaws_between_points, goal_yaw)) <= M_PI_2,
+      yaws_between_points,
+      utils::normalize_angles(yaws_between_points + M_PI)));
+
   const auto yaws =
-    xt::abs(utils::shortest_angular_distance(data.trajectories.yaws, yaws_between_points));
+    xt::abs(
+    utils::shortest_angular_distance(
+      data.trajectories.yaws,
+      yaws_between_points_corrected));
 
   data.costs += xt::pow(xt::mean(yaws, {1}, immediate) * weight_, power_);
 }