Add clang-format from RAI

Signed-off-by: Kacper Dąbrowski <[email protected]>

Author: knicked

ros2_ws/src/robotic_manipulation/.clang-format

@@ -0,0 +1,18 @@
+Language: Cpp
+BasedOnStyle: Google
+
+AccessModifierOffset: -2
+AlignAfterOpenBracket: AlwaysBreak
+BraceWrapping:
+  AfterClass: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterStruct: true
+  AfterEnum: true
+BreakBeforeBraces: Custom
+ColumnLimit: 100
+ConstructorInitializerIndentWidth: 0
+ContinuationIndentWidth: 2
+DerivePointerAlignment: false
+PointerAlignment: Middle
+ReflowComments: false

ros2_ws/src/robotic_manipulation/include/robotic_manipulation/arm_controller.h

@@ -17,18 +17,17 @@
 
 #include <moveit/move_group_interface/move_group_interface.h>
 
-class ArmController {
+class ArmController
+{
 public:
   ArmController() = default;
   ~ArmController();
 
   void Initialize();
 
-  geometry_msgs::msg::Pose CalculatePose(double x, double y, double z,
-                                         double r = 0.0);
+  geometry_msgs::msg::Pose CalculatePose(double x, double y, double z, double r = 0.0);
 
-  bool
-  MoveThroughWaypoints(std::vector<geometry_msgs::msg::Pose> const &waypoints);
+  bool MoveThroughWaypoints(std::vector<geometry_msgs::msg::Pose> const & waypoints);
 
   void Open();
   void Close();
@@ -37,9 +36,9 @@ class ArmController {
   bool GetGripper();
 
   std::vector<double> CaptureJointValues();
-  bool SetJointValues(std::vector<double> const &jointValues);
+  bool SetJointValues(std::vector<double> const & jointValues);
 
-  void SetReferenceFrame(std::string const &frame);
+  void SetReferenceFrame(std::string const & frame);
 
 private:
   // The joint values for the gripper to be open and closed.

ros2_ws/src/robotic_manipulation/src/arm_controller.cpp

@@ -15,11 +15,11 @@
 
 #include "robotic_manipulation/arm_controller.h"
 
-#include <rosgraph_msgs/msg/clock.hpp>
-
 #include <numbers>
+#include <rosgraph_msgs/msg/clock.hpp>
 
-void ArmController::Initialize() {
+void ArmController::Initialize()
+{
   m_node = rclcpp::Node::make_shared("arm_controller");
   m_node->set_parameter(rclcpp::Parameter("use_sim_time", true));
 
@@ -28,32 +28,31 @@ void ArmController::Initialize() {
   m_executor.add_node(m_node);
   m_spinner = std::thread([this]() { m_executor.spin(); });
 
-  m_pandaArm = std::make_shared<moveit::planning_interface::MoveGroupInterface>(
-      m_node, "panda_arm");
-  m_hand = std::make_shared<moveit::planning_interface::MoveGroupInterface>(
-      m_node, "hand");
+  m_pandaArm =
+    std::make_shared<moveit::planning_interface::MoveGroupInterface>(m_node, "panda_arm");
+  m_hand = std::make_shared<moveit::planning_interface::MoveGroupInterface>(m_node, "hand");
 
   m_pandaArm->setMaxVelocityScalingFactor(1.0);
   m_pandaArm->setMaxAccelerationScalingFactor(1.0);
 }
 
-ArmController::~ArmController() {
+ArmController::~ArmController()
+{
   m_executor.cancel();
   if (m_spinner.joinable()) {
     m_spinner.join();
   }
 }
 
-geometry_msgs::msg::Pose ArmController::CalculatePose(double x, double y,
-                                                      double z, double r) {
+geometry_msgs::msg::Pose ArmController::CalculatePose(double x, double y, double z, double r)
+{
   geometry_msgs::msg::Pose pose;
   pose.position.x = x;
   pose.position.y = y;
   pose.position.z = z;
 
   auto quat = tf2::Quaternion();
-  quat.setEuler(EndEffectorBaseRoll, EndEffectorBasePitch,
-                EndEffectorBaseYaw + r);
+  quat.setEuler(EndEffectorBaseRoll, EndEffectorBasePitch, EndEffectorBaseYaw + r);
   pose.orientation.x = quat.x();
   pose.orientation.y = quat.y();
   pose.orientation.z = quat.z();
@@ -62,72 +61,75 @@ geometry_msgs::msg::Pose ArmController::CalculatePose(double x, double y,
   return pose;
 }
 
-bool ArmController::MoveThroughWaypoints(
-    std::vector<geometry_msgs::msg::Pose> const &waypoints) {
+bool ArmController::MoveThroughWaypoints(std::vector<geometry_msgs::msg::Pose> const & waypoints)
+{
   auto logger = m_node->get_logger();
 
   int constexpr NumTries = 10;
   for (int i = 0; i < NumTries; i++) {
     moveit_msgs::msg::RobotTrajectory trajectory;
-    if (m_pandaArm->computeCartesianPath(waypoints, 0.01, 0.0, trajectory) ==
-        -1) {
-      RCLCPP_ERROR(logger,
-                   "MoveThroughWaypoints: Failed to compute Cartesian path");
+    if (m_pandaArm->computeCartesianPath(waypoints, 0.01, 0.0, trajectory) == -1) {
+      RCLCPP_ERROR(logger, "MoveThroughWaypoints: Failed to compute Cartesian path");
       continue;
     }
 
-    if (m_pandaArm->execute(trajectory) ==
-        moveit::core::MoveItErrorCode::SUCCESS) {
+    if (m_pandaArm->execute(trajectory) == moveit::core::MoveItErrorCode::SUCCESS) {
       return true;
     }
-    RCLCPP_ERROR(logger, "MoveThroughWaypoints: Failed to execute "
-                         "trajectory, trying again...");
+    RCLCPP_ERROR(
+      logger,
+      "MoveThroughWaypoints: Failed to execute "
+      "trajectory, trying again...");
   }
 
   RCLCPP_ERROR(
-      logger,
-      "MoveThroughWaypoints: Failed to execute trajectory after %d tries",
-      NumTries);
+    logger, "MoveThroughWaypoints: Failed to execute trajectory after %d tries", NumTries);
   return false;
 }
 
-void ArmController::Open() {
+void ArmController::Open()
+{
   gripper.store(true);
   m_hand->setJointValueTarget("panda_finger_joint1", OpenGripperJointValue);
   while (m_hand->move() != moveit::core::MoveItErrorCode::SUCCESS) {
     RCLCPP_ERROR(m_node->get_logger(), "Failed to open hand");
   }
 }
 
-void ArmController::Close() {
+void ArmController::Close()
+{
   gripper.store(false);
   m_hand->setJointValueTarget("panda_finger_joint1", ClosedGripperJointValue);
   while (m_hand->move() != moveit::core::MoveItErrorCode::SUCCESS) {
     RCLCPP_ERROR(m_node->get_logger(), "Failed to close hand");
   }
 }
 
-std::vector<double> ArmController::GetEffectorPose() {
+std::vector<double> ArmController::GetEffectorPose()
+{
   auto pose = m_pandaArm->getCurrentPose().pose;
-  auto rotation = tf2::Quaternion(pose.orientation.x, pose.orientation.y,
-                                  pose.orientation.z, pose.orientation.w);
+  auto rotation =
+    tf2::Quaternion(pose.orientation.x, pose.orientation.y, pose.orientation.z, pose.orientation.w);
   tf2::Matrix3x3 m(rotation);
   m.getRPY(pose.orientation.x, pose.orientation.y, pose.orientation.z, 0);
-  return {pose.position.x,
-          pose.position.y,
-          pose.position.z,
-          pose.orientation.x,
-          pose.orientation.y - EndEffectorBasePitch,
-          pose.orientation.z - (tf2Radians(180.0) - EndEffectorBaseYaw)};
+  return {
+    pose.position.x,
+    pose.position.y,
+    pose.position.z,
+    pose.orientation.x,
+    pose.orientation.y - EndEffectorBasePitch,
+    pose.orientation.z - (tf2Radians(180.0) - EndEffectorBaseYaw)};
 };
 
 bool ArmController::GetGripper() { return gripper.load(); }
 
-std::vector<double> ArmController::CaptureJointValues() {
+std::vector<double> ArmController::CaptureJointValues()
+{
   return m_pandaArm->getCurrentJointValues();
 }
 
-bool ArmController::SetJointValues(std::vector<double> const &jointValues) {
+bool ArmController::SetJointValues(std::vector<double> const & jointValues)
+{
   m_pandaArm->setJointValueTarget(jointValues);
   if (m_pandaArm->move() != moveit::core::MoveItErrorCode::SUCCESS) {
     RCLCPP_ERROR(m_node->get_logger(), "Failed to set joint values");
@@ -136,17 +138,18 @@ bool ArmController::SetJointValues(std::vector<double> const &jointValues) {
   return true;
 }
 
-void ArmController::SetReferenceFrame(std::string const &frame) {
+void ArmController::SetReferenceFrame(std::string const & frame)
+{
   m_pandaArm->setPoseReferenceFrame(frame);
 }
 
-void ArmController::WaitForClockMessage() {
+void ArmController::WaitForClockMessage()
+{
   bool clockReceived = false;
   auto qos = rclcpp::QoS(rclcpp::KeepLast(1));
   qos.best_effort();
   auto subscription = m_node->create_subscription<rosgraph_msgs::msg::Clock>(
-      "/clock", qos,
-      [&](rosgraph_msgs::msg::Clock::SharedPtr) { clockReceived = true; });
+    "/clock", qos, [&](rosgraph_msgs::msg::Clock::SharedPtr) { clockReceived = true; });
   while (!clockReceived) {
     rclcpp::spin_some(m_node);
   }