Work on documentation

Signed-off-by: Simon Eisenmann <simon.eisenmann@driveblocks.ai>

Author: simon-eisenmann-driveblocks

planning/mapless_architecture/autoware_hmi/include/autoware/hmi/hmi_node.hpp

@@ -27,10 +27,6 @@ class HMINode : public rclcpp::Node
   HMINode();
 
 private:
-  // ###########################################################################
-  // #  PRIVATE PROCESSING METHODS
-  // ###########################################################################
-
   /**
    * @brief Callback function for parameter changes.
    * This callback function is triggered whenever a ROS 2 parameter is changed.
@@ -46,9 +42,6 @@ class HMINode : public rclcpp::Node
    */
   void PublishMission_(std::string mission);
 
-  // ###########################################################################
-  // #  PRIVATE VARIABLES
-  // ###########################################################################
   // Declare ROS2 publisher and subscriber
 
   rclcpp::Publisher<autoware_planning_msgs::msg::Mission>::SharedPtr mission_publisher_;

planning/mapless_architecture/autoware_hmi/src/hmi_node.cpp

@@ -11,14 +11,6 @@ namespace autoware::mapless_architecture
 {
 using std::placeholders::_1;
 
-/**
-
-* @brief Constructor for the HMINode class.
-
-* Initializes the publisher and subscriber with appropriate topics and QoS
-settings.
-
-*/
 HMINode::HMINode() : Node("hmi_node")
 {
   // Set quality of service to best effort (if transmission fails, do not try to

planning/mapless_architecture/autoware_local_map_provider/include/autoware/local_map_provider/local_map_provider_node.hpp

@@ -26,20 +26,13 @@ class LocalMapProviderNode : public rclcpp::Node
   LocalMapProviderNode();
 
 private:
-  // ###########################################################################
-  // #  PRIVATE PROCESSING METHODS
-  // ###########################################################################
-
   /**
    * @brief The callback for the RoadSegments messages.
    *
    * @param msg The autoware_planning_msgs::msg::RoadSegments message.
    */
   void CallbackRoadSegmentsMessages_(const autoware_planning_msgs::msg::RoadSegments & msg);
 
-  // ###########################################################################
-  // #  PRIVATE VARIABLES
-  // ###########################################################################
   // Declare ROS2 publisher and subscriber
 
   rclcpp::Publisher<autoware_planning_msgs::msg::LocalMap>::SharedPtr map_publisher_;

planning/mapless_architecture/autoware_local_mission_planner/include/autoware/local_mission_planner/mission_planner_node.hpp

@@ -30,14 +30,15 @@
 namespace autoware::mapless_architecture
 {
 
-// Create Direction data type
+// Direction data type
 typedef int Direction;
 const Direction stay = 0;
 const Direction left = 1;
 const Direction right = 2;
 const Direction left_most = 3;
 const Direction right_most = 4;
 
+// Define Lanes
 struct Lanes
 {
   std::vector<int> ego;
@@ -204,10 +205,6 @@ class MissionPlannerNode : public rclcpp::Node
     std::vector<LaneletConnection> & out_lanelet_connections);
 
 private:
-  // ###########################################################################
-  // #  PRIVATE PROCESSING METHODS
-  // ###########################################################################
-
   /**
    * @brief Function for the visualization of lanes.
    *
@@ -283,9 +280,6 @@ class MissionPlannerNode : public rclcpp::Node
    */
   void CalculatePredecessors(std::vector<LaneletConnection> & lanelet_connections);
 
-  // ###########################################################################
-  // #  PRIVATE VARIABLES
-  // ###########################################################################
   //  Declare ROS2 publisher and subscriber
   rclcpp::Subscription<autoware_planning_msgs::msg::LocalMap>::SharedPtr mapSubscriber_;
 
@@ -309,11 +303,12 @@ class MissionPlannerNode : public rclcpp::Node
   // ROS buffer interface (for TF transforms)
   std::unique_ptr<tf2_ros::Buffer> tf_buffer_;
   std::unique_ptr<tf2_ros::TransformListener> tf_listener_;
-  // store previous odometry message
+
+  // Store previous odometry message
   nav_msgs::msg::Odometry last_odom_msg_;
-  Pose2D pose_prev_;
-  // Pose2D target_pose_ = {0.0, 0.0};
 
+  // Initialize some variables
+  Pose2D pose_prev_;
   bool pose_prev_init_ = false;
   bool b_global_odometry_deprecation_warning_ = false;
   bool received_motion_update_once_ = false;
@@ -329,7 +324,7 @@ class MissionPlannerNode : public rclcpp::Node
   std::vector<int> lane_right_;
   std::vector<lanelet::Lanelet> current_lanelets_;
 
-  // ros parameters
+  // ROS parameters
   float distance_to_centerline_threshold_;
   float projection_distance_on_goallane_;
   int retrigger_attempts_max_;

planning/mapless_architecture/autoware_local_mission_planner/test/src/test_mission_planner_core.cpp

@@ -127,6 +127,7 @@ int TestCalculateDistanceBetweenPointAndLineString()
 {
   // Create an example Linestring
   lanelet::LineString2d linestring;
+
   lanelet::Point2d p1(0, 1.0,
                       0.0);  // First argument is ID (set it to 0 for now)
   linestring.push_back(p1);
@@ -241,7 +242,7 @@ db_msgs::msg::LaneletsStamped GetTestRoadModelForRecenterTests()
   std::vector<db_msgs::msg::Lanelet> lanelet_vec(n_lanelets);
   message.lanelets = lanelet_vec;
 
-  // global position
+  // Global position
   geometry_msgs::msg::PoseStamped msg_global_pose;
   msg_global_pose.header.frame_id = "base_link";
 
@@ -267,7 +268,7 @@ db_msgs::msg::LaneletsStamped GetTestRoadModelForRecenterTests()
 
   tf2::Quaternion quaternion;
 
-  // vehicle position in global cosy
+  // Vehicle position in global cosy
   message.pose.position.x = 0.0;
   message.pose.position.y = 0.0;
   quaternion.setRPY(0, 0, 0);
@@ -276,7 +277,7 @@ db_msgs::msg::LaneletsStamped GetTestRoadModelForRecenterTests()
   message.pose.orientation.z = quaternion.getZ();
   message.pose.orientation.w = quaternion.getW();
 
-  // street layout in current local cosy = global cosy since vehicle position is
+  // Street layout in current local cosy = global cosy since vehicle position is
   // at the origin in the global cosy
   message.lanelets[0].linestrings[0].points[0].pose.position.x = 0.0;
   message.lanelets[0].linestrings[0].points[0].pose.position.y = -0.5;
@@ -349,7 +350,7 @@ int TestRecenterGoalpoint()
   goal_point.y() = 0.25;
   goal_point_recentered = mission_planner.RecenterGoalPoint(goal_point, converted_lanelets);
 
-  // expect re-centered point to lie on y coordinate 0
+  // Expect re-centered point to lie on y coordinate 0
   EXPECT_NEAR(goal_point_recentered.x(), goal_point.x(), 1e-5);
   EXPECT_NEAR(goal_point_recentered.y(), 0.0, 1e-5);
 
@@ -359,7 +360,7 @@ int TestRecenterGoalpoint()
   goal_point.y() = -0.2;
   goal_point_recentered = mission_planner.RecenterGoalPoint(goal_point, converted_lanelets);
 
-  // expect re-centered point to lie on y coordinate 0 but with x coord equal to
+  // Expect re-centered point to lie on y coordinate 0 but with x coord equal to
   // goal_point (removes lateral error/noise)
   EXPECT_NEAR(goal_point_recentered.x(), goal_point.x(), 1e-5);
   EXPECT_NEAR(goal_point_recentered.y(), 0.0, 1e-5);
@@ -371,7 +372,7 @@ int TestRecenterGoalpoint()
   goal_point.y() = 1.75;
   goal_point_recentered = mission_planner.RecenterGoalPoint(goal_point, converted_lanelets);
 
-  // expect re-centered point to lie on y coordinate 0 but with x coord equal to
+  // Expect re-centered point to lie on y coordinate 0 but with x coord equal to
   // goal_point (removes lateral error/noise)
   EXPECT_NEAR(goal_point_recentered.x(), goal_point.x(), 1e-5);
   EXPECT_NEAR(goal_point_recentered.y(), 1.5, 1e-5);
@@ -416,7 +417,7 @@ int TestCheckIfGoalPointShouldBeReset()
   lanelet::BasicPoint2d point(-1.0, 0.0);
   MissionPlanner.goal_point(point);
 
-  // set a non-default mission to make the goal point reset work
+  // Set a non-default mission to make the goal point reset work
   autoware_planning_msgs::msg::Mission mission_msg;
   mission_msg.mission_type = autoware_planning_msgs::msg::Mission::LANE_CHANGE_LEFT;
   MissionPlanner.CallbackMissionMessages_(mission_msg);
@@ -433,7 +434,7 @@ int TestCheckIfGoalPointShouldBeReset()
   // TEST 2: check if goal point reset is skipped in default mission
   MissionPlanner.goal_point(point);
 
-  // set a non-default mission to make the goal point reset work
+  // Set a non-default mission to make the goal point reset work
   mission_msg.mission_type = autoware_planning_msgs::msg::Mission::LANE_KEEP;
   MissionPlanner.CallbackMissionMessages_(mission_msg);
 

planning/mapless_architecture/autoware_local_mission_planner_common/include/autoware/local_mission_planner_common/helper_functions.hpp

@@ -30,7 +30,7 @@ class Pose2D
   Pose2D();
   Pose2D(const double x, const double y, const double psi = 0.0);
 
-  // accessors and mutators
+  // Accessors and mutators
   double get_x() const;
   double get_y() const;
   Eigen::Vector2d get_xy() const;
@@ -43,7 +43,7 @@ class Pose2D
   void set_psi(const double psi);
 
 private:
-  // data variables
+  // Data variables
   Eigen::Vector2d xy_;
   double psi_;
 };
@@ -57,9 +57,9 @@ class Pose2D
  * providing the absolute pose of the new cosy as "pose_prev" and the
  * absolute pose of the old/current cosy as "cosy_rel".
  *
- * @param cosy_rel translation and rotation between the current/old cosy and
+ * @param cosy_rel Translation and rotation between the current/old cosy and
  * a new/go-to cosy
- * @param pose_prev coordinates and heading of a pose in the current/old cosy
+ * @param pose_prev Coordinates and heading of a pose in the current/old cosy
  * @return Pose coordinates and heading of pose_prev in the new cosy
  * (defined by the shift cosy_rel between previous and current cosy)
  */
@@ -148,7 +148,7 @@ std::vector<std::vector<int>> GetAllSuccessorSequences(
 * @param id_initial_lanelet    ID of lanelet from where neighbor search is
                               started
 * @param adjacent_lane_type    Specifies whether predecessors or successors
-should be targeted (e.g.  lanelet_tools::AdjacentLaneType::kPredecessors)
+should be targeted (e.g. lanelet_tools::AdjacentLaneType::kPredecessors)
 *
 * @return Collection of sequences of all adjacent lanelets
 */
@@ -157,18 +157,16 @@ std::vector<std::vector<int>> GetAllLaneletSequences(
   const AdjacentLaneType adjacent_lane_type);
 
 /**
-* @brief Find relevant adjacent (successors or predecessors) lanelets
-        (currently relevant means leading towards goal) among a set of
-provided adjacent lanelets (ids_adjacent_lanelets)
+* @brief Find relevant adjacent (successors or predecessors) lanelets (currently relevant means
+leading towards goal) among a set of provided adjacent lanelets (ids_adjacent_lanelets)
 *
 * @param lanelet_connections   Relation between individual lanelets
                               (successors/neighbors)
 * @param ids_adjacent_lanelets IDs of all available adjacent lanelets
                               (either successors or predecessors)
 * @param do_include_navigation_info  Whether to use navigation info to
-*            determine relevant successors (true) or not (false); if
-navigation info is not used, the ID of the first direct successors will be
-            returned
+*            determine relevant successors (true) or not (false); if navigation info is not used,
+the ID of the first direct successors will be returned
 * @return    ID of relevant successor lanelet
 */
 std::vector<int> GetRelevantAdjacentLanelets(
@@ -179,11 +177,10 @@ std::vector<int> GetRelevantAdjacentLanelets(
  * @brief Get a complete lanelet ID sequence starting from an initial lanelet.
  *
  * @param lanelet_id_sequence_current  Current lanelet ID sequence (of
- * previous iteration); this is the start for the search in the current
- * iteration
+ * previous iteration); this is the start for the search in the current iteration
  * @param lanelets_already_visited      List of already visited lanelet IDs
- * @param ids_relevant_lanelets         IDs of the relevant adjacent
- * (successor or predecessor) lanelets
+ * @param ids_relevant_lanelets         IDs of the relevant adjacent (successor or predecessor)
+ * lanelets
  * @param id_initial_lanelet            ID of lanelet from which search was
  *                                      started initially
  * @return  - Vector containing IDs of a completed lanelet sequence; is empty
@@ -197,7 +194,7 @@ std::tuple<std::vector<int>, bool> GetCompletedLaneletSequence(
   const std::vector<int> ids_relevant_lanelets, const int id_initial_lanelet);
 
 /**
- * @brief The vehicle side.
+ * @brief The vehicle side (left or right).
  *
  */
 enum VehicleSide { kLeft = 0, kRight = 1 };
@@ -231,15 +228,13 @@ std::vector<int> GetAllNeighboringLaneletIDs(
  *                                    determine relevant neighbors (true) or
  *                                    not (false)
  * @param recursiveness (defaults to 1)
- *    level of recursiveness for neighbor search
- *    - recursivenes=-1 means that the most outside lanes are requested
- (returns initial lanelet ID if no neighbors are available -> initial lanelet
- is the most outside lane)
- *    - recursiveness>=0 means that the direct neighbors (1), neighbors of
-        neighbors (2), ..., are searched (returns -1 if no lanelet is
- available at the specified level of recursiveness)
+ *    - level of recursiveness for neighbor search
+ *    - recursivenes=-1 means that the most outside lanes are requested (returns initial lanelet ID
+ if no neighbors are available -> initial lanelet is the most outside lane)
+ *    - recursiveness>=0 means that the direct neighbors (1), neighbors of neighbors (2), ..., are
+ searched (returns -1 if no lanelet is available at the specified level of recursiveness)
  *
- * @return    ID of neighboring lanelet (returns -1 if no neighbor available)
+ * @return ID of neighboring lanelet (returns -1 if no neighbor available)
  */
 int GetNeighboringLaneletID(
   const std::vector<LaneletConnection> & lanelet_connections, const int id_initial_lanelet,

planning/mapless_architecture/autoware_local_mission_planner_common/src/helper_functions.cpp

@@ -13,10 +13,10 @@ namespace autoware::mapless_architecture
 
 double NormalizePsi(const double psi)
 {
-  // remove multiples of 2 PI by using modulo on absolute value and apply sign
+  // Remove multiples of 2 PI by using modulo on absolute value and apply sign
   double psi_out = copysign(fmod(fabs(psi), M_PI * 2.0), psi);
 
-  // restrict psi to [-pi, pi[
+  // Restrict psi to [-pi, pi[
   if (psi_out >= M_PI)
     psi_out -= 2.0 * M_PI;
   else if (psi_out < -M_PI)
@@ -30,22 +30,22 @@ std::vector<double> GetPsiForPoints(const std::vector<geometry_msgs::msg::Point>
   int num_points = points.size();
   std::vector<double> tang_vecs(num_points * 2);
 
-  // get heading vector for first point
+  // Get heading vector for first point
   tang_vecs[0] = points[1].x - points[0].x;
   tang_vecs[1] = points[1].y - points[0].y;
 
-  // use one point before and after the targeted one for heading vector (more
+  // Use one point before and after the targeted one for heading vector (more
   // stable/robust than relying on a single pair of points)
   for (int i = 1; i < num_points - 1; i++) {
     tang_vecs[2 * i] = points[i + 1].x - points[i - 1].x;
     tang_vecs[2 * i + 1] = points[i + 1].y - points[i - 1].y;
   }
 
-  // get heading vector for last point
+  // Get heading vector for last point
   tang_vecs[2 * (num_points - 1)] = points[num_points - 1].x - points[num_points - 2].x;
   tang_vecs[2 * (num_points - 1) + 1] = points[num_points - 1].y - points[num_points - 2].y;
 
-  // calculate heading angles with atan2
+  // Calculate heading angles with atan2
   std::vector<double> psi_points(num_points);
   for (int i = 0; i < num_points; i++) {
     psi_points[i] = NormalizePsi(std::atan2(tang_vecs[2 * i + 1], tang_vecs[2 * i]));
@@ -59,50 +59,61 @@ Pose2D::Pose2D()
   this->set_xy(0.0, 0.0);
   this->set_psi(0.0);
 }
+
 Pose2D::Pose2D(const double x, const double y, const double psi /* = 0.0 */)
 {
   this->set_xy(x, y);
   this->set_psi(psi);
 }
+
 double Pose2D::get_x() const
 {
   return this->xy_(0);
 }
+
 double Pose2D::get_y() const
 {
   return this->xy_(1);
 }
+
 Eigen::Vector2d Pose2D::get_xy() const
 {
   return this->xy_;
 }
+
 double Pose2D::get_psi() const
 {
   return this->psi_;
 }
+
 geometry_msgs::msg::Point Pose2D::get_point() const
 {
   geometry_msgs::msg::Point tmp_point;
   tmp_point.x = this->xy_(0);
   tmp_point.y = this->xy_(1);
   return tmp_point;
 }
+
 void Pose2D::set_x(const double x)
 {
   this->xy_(0) = x;
 }
+
 void Pose2D::set_y(const double y)
 {
   this->xy_(1) = y;
 }
+
 void Pose2D::set_xy(const double x, const double y)
 {
   this->xy_ = {x, y};
 }
+
 void Pose2D::set_xy(const Eigen::Vector2d xy)
 {
   this->xy_ = xy;
 }
+
 void Pose2D::set_psi(const double psi)
 {
   this->psi_ = psi;
@@ -189,15 +200,15 @@ std::vector<std::vector<int>> GetAllLaneletSequences(
   const std::vector<LaneletConnection> & lanelet_connections, const int id_initial_lanelet,
   const AdjacentLaneType adjacent_lane_type)
 {
-  // initialize helper variables
+  // Initialize helper variables
   bool do_include_navigation_info = false;
 
   std::vector<int> lanelets_already_visited;
   std::vector<int> lanelet_id_sequence_temp{id_initial_lanelet};
 
   std::vector<std::vector<int>> lanelet_sequences;
 
-  // loop as long as all successors of the initial lanelet have been searched
+  // Loop as long as all successors of the initial lanelet have been searched
   // maximum iteration depth is (number_of_lanelets - 1) * 2
   for (size_t i = 0; i < lanelet_connections.size() * 2; i++) {
     // IDs which are relevant for searching adjacent lanelets (either successors
@@ -221,7 +232,7 @@ std::vector<std::vector<int>> GetAllLaneletSequences(
 
     if (do_exit_outer_for_loop) break;
 
-    // store returned complete lanelet id sequence
+    // Store returned complete lanelet id sequence
     if (!lanelet_id_sequence_completed.empty()) {
       lanelet_sequences.push_back(lanelet_id_sequence_completed);
     }
@@ -235,19 +246,19 @@ std::vector<int> GetRelevantAdjacentLanelets(
 {
   std::vector<int> ids_relevant_successors;
 
-  // return all successors if navigation info is not relevant
+  // Return all successors if navigation info is not relevant
   if (do_include_navigation_info) {
-    // loop through all successors and check if they lead towards the navigation
+    // Loop through all successors and check if they lead towards the navigation
     // goal
     if (ids_adjacent_lanelets.front() >= 0) {
       for (std::size_t i = 0; i < ids_adjacent_lanelets.size(); i++) {
-        // check if successor leads to goal
+        // Check if successor leads to goal
         if (lanelet_connections[ids_adjacent_lanelets[i]].goal_information) {
           ids_relevant_successors.push_back(ids_adjacent_lanelets[i]);
         }
       }
     }
-    // default return: valid successor lanelet not available
+    // Default return: valid successor lanelet not available
     if (ids_relevant_successors.empty()) {
       ids_relevant_successors.push_back(-1);
     }
@@ -256,9 +267,7 @@ std::vector<int> GetRelevantAdjacentLanelets(
   }
 
   // FIXME: avoid that list is empty -> has to be -1 if no relevant lanelet
-  // exists
-  // this fixes an issue that originates in the lanelet converter; should be
-  // fixed there!
+  // exists, this fixes an issue that originates in the lanelet converter; should be fixed there!
   if (ids_relevant_successors.empty()) {
     ids_relevant_successors.push_back(-1);
   }
@@ -273,47 +282,47 @@ std::tuple<std::vector<int>, bool> GetCompletedLaneletSequence(
   std::vector<int> lanelet_id_sequence_completed;
   bool do_exit_outer_for_loop = false;
 
-  // check if an adjacent lanelet is even available
+  // Check if an adjacent lanelet is even available
   if (ids_relevant_lanelets.front() >= 0) {
     bool has_relevant_successor = false;
 
-    // loop though all relevant adjacent IDs and check whether or not they
+    // Loop though all relevant adjacent IDs and check whether or not they
     // have already been visited
     for (const int & successor_id : ids_relevant_lanelets) {
       if (
         std::find(lanelets_already_visited.begin(), lanelets_already_visited.end(), successor_id) ==
         lanelets_already_visited.end()) {
-        // add new ID to already visited vector
+        // Add new ID to already visited vector
         lanelets_already_visited.push_back(successor_id);
-        // add currently visited ID to temporary adjacent lanelet sequence
+        // Add currently visited ID to temporary adjacent lanelet sequence
         lanelet_id_sequence_current.push_back(successor_id);
         has_relevant_successor = true;
         break;
       }
     }
 
-    // if all available adjacent lanelets were already visited, go back to
+    // If all available adjacent lanelets were already visited, go back to
     // parent lanelet or exit loop
     if (!has_relevant_successor) {
-      // pop parent lanelet except it is already the initial lanelet
+      // Pop parent lanelet except it is already the initial lanelet
       if (lanelet_id_sequence_current.back() != id_initial_lanelet) {
         lanelet_id_sequence_current.pop_back();
       } else {
-        // exit loop if initial lanelet has no relevant adjacent lanelets left
+        // Exit loop if initial lanelet has no relevant adjacent lanelets left
         do_exit_outer_for_loop = true;
       }
     }
 
   } else {
-    // exit loop if initial lanelet has already no relevant adjacent lanelets
+    // Exit loop if initial lanelet has already no relevant adjacent lanelets
     if (lanelet_id_sequence_current.back() == id_initial_lanelet) {
       do_exit_outer_for_loop = true;
     } else {
-      // store lanelet sequence when it is completed (no unvisited adjacent
+      // Store lanelet sequence when it is completed (no unvisited adjacent
       // lanelets left from current lanelet)
       lanelet_id_sequence_completed = lanelet_id_sequence_current;
 
-      // go back to parent lanelet ID and continue search from there
+      // Go back to parent lanelet ID and continue search from there
       lanelet_id_sequence_current.pop_back();
     }
   }
@@ -327,24 +336,23 @@ std::vector<int> GetAllNeighboringLaneletIDs(
   int id_current_lanelet = id_initial_lanelet;
   std::vector<int> lanelet_id_neighbors;
 
-  // this function is only intended to return all neighboring lanelets, not only
+  // This function is only intended to return all neighboring lanelets, not only
   // the ones leading towards goal. Therefore, this flag is set false for the
   // sub-function.
   const bool do_include_navigation_info = false;
 
-  // loop as long as all left or right neighbors of the initial lanelet have
-  // been searched
-  // maximum iteration depth is: number_of_lanelets
+  // Loop as long as all left or right neighbors of the initial lanelet have
+  // been searched, maximum iteration depth is: number_of_lanelets
   for (size_t i = 0; i < lanelet_connections.size(); i++) {
     int idx_tmp = GetNeighboringLaneletID(
       lanelet_connections, id_current_lanelet, side, do_include_navigation_info);
 
-    // if ID >= 0, continue search, else break
+    // If ID >= 0, continue search, else break
     if (idx_tmp >= 0) {
       id_current_lanelet = idx_tmp;
       lanelet_id_neighbors.push_back(id_current_lanelet);
     } else {
-      // if return vector is still empty because no neighbors are available,
+      // If return vector is still empty because no neighbors are available,
       // return -1
       if (lanelet_id_neighbors.empty()) {
         lanelet_id_neighbors.push_back(-1);
@@ -360,45 +368,45 @@ int GetNeighboringLaneletID(
   const std::vector<LaneletConnection> & lanelet_connections, const int id_initial_lanelet,
   const VehicleSide side, const bool do_include_navigation_info, const int recursiveness)
 {
-  // set default return id if initial lane has already no neighbors
+  // Set default return id if initial lane has already no neighbors
   int id_neighbor_lanelet = -1;
 
-  // check if most outside lane is searched
-  // here: return current lanelet's ID when no neighbors are available
+  // Check if most outside lane is searched
+  // Here: return current lanelet's ID when no neighbors are available
   if (recursiveness == -1) {
     id_neighbor_lanelet = id_initial_lanelet;
   }
 
-  // get ID of current lanelet's neighboring lanelet
+  // Get ID of current lanelet's neighboring lanelet
   int id_neighbor_lanelet_tmp = lanelet_connections[id_initial_lanelet].neighbor_lanelet_ids[side];
 
-  // init counter to track current level of recursiveness in loop
+  // Init counter to track current level of recursiveness in loop
   int recursiveness_counter = 0;
 
-  // loop as long as all neighbors of the initial lanelet have been searched
-  // maximum iteration depth: number_of_lanelets
+  // Loop as long as all neighbors of the initial lanelet have been searched, maximum iteration
+  // depth: number_of_lanelets
   for (size_t i = 0; i < lanelet_connections.size(); i++) {
-    // break while loop if desired recursiveness is reached
+    // Break while loop if desired recursiveness is reached
     if (recursiveness != -1 && recursiveness_counter >= recursiveness) break;
 
-    // check if neighbor is available
+    // Check if neighbor is available
     if (id_neighbor_lanelet_tmp >= 0) {
-      // break if navigation info is considered AND the lanelet does not lead
+      // Break if navigation info is considered AND the lanelet does not lead
       // towards goal
       if (
         do_include_navigation_info &&
         !lanelet_connections[id_neighbor_lanelet_tmp].goal_information) {
         break;
       }
 
-      // store current neighbor lanelet ID
+      // Store current neighbor lanelet ID
       id_neighbor_lanelet = id_neighbor_lanelet_tmp;
-      // query neighbor of neighbor and use as new start lanelet
+      // Query neighbor of neighbor and use as new start lanelet
       id_neighbor_lanelet_tmp =
         lanelet_connections[id_neighbor_lanelet_tmp].neighbor_lanelet_ids[side];
 
     } else {
-      // return -1 if lanelet ID at specific recursiveness is requested
+      // Return -1 if lanelet ID at specific recursiveness is requested
       if (recursiveness >= 0) {
         id_neighbor_lanelet = -1;
       }
@@ -422,7 +430,7 @@ int FindOccupiedLaneletID(
 {
   int id_occupied_lanelet = -1;
 
-  // check if position is within one of the available lanelet
+  // Check if position is within one of the available lanelet
   for (size_t i = 0; i < lanelets.size(); i++) {
     if (lanelet::geometry::inside(lanelets[i], position)) {
       id_occupied_lanelet = i;

planning/mapless_architecture/autoware_local_road_provider/include/autoware/local_road_provider/local_road_provider_node.hpp

@@ -26,20 +26,13 @@ class LocalRoadProviderNode : public rclcpp::Node
   LocalRoadProviderNode();
 
 private:
-  // ###########################################################################
-  // #  PRIVATE PROCESSING METHODS
-  // ###########################################################################
-
   /**
    * @brief The callback for the LaneletsStamped messages.
    *
    * @param msg The db_msgs::msg::LaneletsStamped message.
    */
   void CallbackLaneletsMessages_(const db_msgs::msg::LaneletsStamped & msg);
 
-  // ###########################################################################
-  // #  PRIVATE VARIABLES
-  // ###########################################################################
   // Declare ROS2 publisher and subscriber
 
   rclcpp::Publisher<autoware_planning_msgs::msg::RoadSegments>::SharedPtr road_publisher_;

planning/mapless_architecture/autoware_mission_lane_converter/include/autoware/mission_lane_converter/mission_lane_converter_node.hpp

@@ -27,30 +27,21 @@ class MissionLaneConverterNode : public rclcpp::Node
 public:
   MissionLaneConverterNode();
 
-  // ###########################################################################
-  // #  PUBLIC METHODS
-  // ###########################################################################
-
   /**
    * @brief Converts the mission message into a reference trajectory which is
    * forwarded to a local trajectory planner for refinement.
    *
    * @param msg The mission lanes
    * @return std::tuple<autoware_auto_planning_msgs::msg::Trajectory,
-           visualization_msgs::msg::Marker,
-           autoware_auto_planning_msgs::msg::Path,
-           visualization_msgs::msg::Marker>
+   * visualization_msgs::msg::Marker, autoware_auto_planning_msgs::msg::Path,
+   * visualization_msgs::msg::Marker>
    */
   std::tuple<
     autoware_auto_planning_msgs::msg::Trajectory, visualization_msgs::msg::Marker,
     autoware_auto_planning_msgs::msg::Path, visualization_msgs::msg::MarkerArray>
   ConvertMissionToTrajectory(const autoware_planning_msgs::msg::MissionLanesStamped & msg);
 
 private:
-  // ###########################################################################
-  // #  PRIVATE PROCESSING METHODS
-  // ###########################################################################
-
   /**
    * @brief Computes a trajectory based on the mission planner input.
    *
@@ -99,14 +90,39 @@ class MissionLaneConverterNode : public rclcpp::Node
    */
   void TimedStartupTrajectoryCallback();
 
+  /**
+   *@brief Create a path bound.
+   *
+   *@param bound_path The path.
+   *@param path_vis The visualization marker.
+   *@param bound_mission_lane The mission lane.
+   *@param id_marker The ID marker.
+   */
   void CreatePathBound_(
     std::vector<geometry_msgs::msg::Point> & bound_path, visualization_msgs::msg::Marker & path_vis,
     const std::vector<geometry_msgs::msg::Point> & bound_mission_lane, const int id_marker);
 
+  /**
+   *@brief Add a path point.
+   *
+   *@param pth_msg The path.
+   *@param x The x value.
+   *@param y The y value.
+   *@param v_x The v_x value.
+   */
   void AddPathPoint_(
     autoware_auto_planning_msgs::msg::Path & pth_msg, const double x, const double y,
     const double v_x);
 
+  /**
+   *@brief Create a motion planner input.
+   *
+   *@param trj_msg The trajectory.
+   *@param path_msg The path.
+   *@param trj_vis The visualization marker for the trajectory.
+   *@param path_vis The visualization marker for the path.
+   *@param centerline_mission_lane The centerline of the mission lane.
+   */
   void CreateMotionPlannerInput_(
     autoware_auto_planning_msgs::msg::Trajectory & trj_msg,
     autoware_auto_planning_msgs::msg::Path & path_msg, visualization_msgs::msg::Marker & trj_vis,
@@ -140,9 +156,6 @@ class MissionLaneConverterNode : public rclcpp::Node
   visualization_msgs::msg::Marker GetGlobalTrjVisualization_(
     const autoware_auto_planning_msgs::msg::Trajectory & trj_msg);
 
-  // ###########################################################################
-  // #  PRIVATE VARIABLES
-  // ###########################################################################
   // Declare ROS2 publisher and subscriber
 
   rclcpp::Subscription<nav_msgs::msg::Odometry>::SharedPtr odom_subscriber_;
@@ -165,17 +178,17 @@ class MissionLaneConverterNode : public rclcpp::Node
 
   rclcpp::TimerBase::SharedPtr timer_;
 
-  // switch to print a warning about wrongly configured odometry frames
+  // Switch to print a warning about wrongly configured odometry frames
   bool b_global_odometry_deprecation_warning_ = false;
   bool received_motion_update_once_ = false;
-  // store initial and last available odom messages
+
+  // Store initial and last available odom messages
   nav_msgs::msg::Odometry last_odom_msg_, initial_odom_msg_;
 
-  // workaround to start the vehicle driving into the computed local road
-  // model
+  // Workaround to start the vehicle driving into the computed local road model
   bool mission_lanes_available_once_ = false;
 
-  // ros parameters
+  // ROS parameters
   float target_speed_;
 };
 }  // namespace autoware::mapless_architecture

planning/mapless_architecture/autoware_mission_lane_converter/src/mission_lane_converter_node.cpp

@@ -7,8 +7,13 @@
 namespace autoware::mapless_architecture
 {
 
+/**
+ * @brief Test the ConvertMissionToTrajectory() function.
+ *
+ * @return int: returns 0 on success
+ */
 int TestMissionToTrajectory();
 
-}
+}  // namespace autoware::mapless_architecture
 
 #endif  // TEST_MISSION_PLANNER_CONVERTER_HPP_

planning/mapless_architecture/autoware_mission_lane_converter/test/include/test_mission_planner_converter.hpp

@@ -15,24 +15,24 @@ int TestMissionToTrajectory()
 
   autoware_planning_msgs::msg::MissionLanesStamped mission_msg;
 
-  // set target lane to ego lane
+  // Set target lane to ego lane
   mission_msg.target_lane = 0;
 
-  // add a driving corridor to the ego lane
+  // Add a driving corridor to the ego lane
   mission_msg.ego_lane = autoware_planning_msgs::msg::DrivingCorridor();
 
-  // add points to the ego lane centerline
+  // Add points to the ego lane centerline
   mission_msg.ego_lane.centerline.push_back(geometry_msgs::msg::Point());
   mission_msg.ego_lane.centerline.back().x = 0.0;
   mission_msg.ego_lane.centerline.back().y = 0.0;
 
-  // get converted trajectory
+  // Get converted trajectory
   std::tuple<
     autoware_auto_planning_msgs::msg::Trajectory, visualization_msgs::msg::Marker,
     autoware_auto_planning_msgs::msg::Path, visualization_msgs::msg::MarkerArray>
     mission_to_trj = mission_converter.ConvertMissionToTrajectory(mission_msg);
 
-  // extract trajectory
+  // Extract trajectory
   autoware_auto_planning_msgs::msg::Trajectory trj_msg = std::get<0>(mission_to_trj);
 
   EXPECT_EQ(trj_msg.points.back().pose.position.x, mission_msg.ego_lane.centerline.back().x);
@@ -51,10 +51,10 @@ int TestMissionToTrajectory()
   mission_msg.ego_lane.centerline.back().x = 2.0;
   mission_msg.ego_lane.centerline.back().y = 2.0;
 
-  // convert
+  // Convert
   mission_to_trj = mission_converter.ConvertMissionToTrajectory(mission_msg);
 
-  // extract trajectory
+  // Extract trajectory
   trj_msg = std::get<0>(mission_to_trj);
 
   EXPECT_EQ(trj_msg.points.back().pose.position.x, mission_msg.ego_lane.centerline.back().x);
@@ -69,13 +69,13 @@ int TestMissionToTrajectory()
   mission_msg.drivable_lanes_left.back().centerline.back().x = 5.0;
   mission_msg.drivable_lanes_left.back().centerline.back().y = 3.0;
 
-  // set target lane to neighbor left
+  // Set target lane to neighbor left
   mission_msg.target_lane = -1;
 
-  // convert
+  // Convert
   mission_to_trj = mission_converter.ConvertMissionToTrajectory(mission_msg);
 
-  // extract trajectory
+  // Extract trajectory
   trj_msg = std::get<0>(mission_to_trj);
 
   EXPECT_EQ(
@@ -94,13 +94,13 @@ int TestMissionToTrajectory()
   mission_msg.drivable_lanes_right.back().centerline.back().x = 3.0;
   mission_msg.drivable_lanes_right.back().centerline.back().y = 3.6;
 
-  // set target lane to neighbor right
+  // Set target lane to neighbor right
   mission_msg.target_lane = 1;
 
-  // convert
+  // Convert
   mission_to_trj = mission_converter.ConvertMissionToTrajectory(mission_msg);
 
-  // extract trajectory
+  // Extract trajectory
   trj_msg = std::get<0>(mission_to_trj);
 
   EXPECT_EQ(