Robot: Code clean with clang-format.

modules/perception/camera/app/cipv_camera.cc

@@ -338,7 +338,7 @@ bool Cipv::FindClosestObjectGround(const std::shared_ptr<base::Object> &object,
 
   double theta_ray = atan2(pos(0), pos(2));
   double theta = object->camera_supplement.alpha + theta_ray;
-  theta -=  M_PI_2;
+  theta -= M_PI_2;
 
   if (debug_level_ >= 3) {
     AINFO << "object->camera_supplement.box = base::RectF("

modules/perception/camera/lib/obstacle/detector/yolo/yolo_obstacle_detector.cc

@@ -150,19 +150,17 @@ void YoloObstacleDetector::InitYoloBlob(const yolo::NetworkParam &net_param) {
   auto obj_blob_scale3 = inference_->get_blob(net_param.det3_obj_blob());
   int output_height_scale1 = obj_blob_scale1->shape(1);
   int output_width_scale1 = obj_blob_scale1->shape(2);
-  int obj_size =
-    output_height_scale1 * output_width_scale1 *
-    static_cast<int>(anchors_.size()) / anchorSizeFactor;
+  int obj_size = output_height_scale1 * output_width_scale1 *
+                 static_cast<int>(anchors_.size()) / anchorSizeFactor;
   if (obj_blob_scale2) {
     int output_height_scale2 = obj_blob_scale2->shape(1);
     int output_width_scale2 = obj_blob_scale2->shape(2);
     int output_height_scale3 = obj_blob_scale3->shape(1);
     int output_width_scale3 = obj_blob_scale3->shape(2);
-    obj_size =
-      (output_height_scale1 * output_width_scale1 +
-       output_height_scale2 * output_width_scale2 +
-       output_height_scale3 * output_width_scale3) *
-      static_cast<int>(anchors_.size()) / anchorSizeFactor / numScales;
+    obj_size = (output_height_scale1 * output_width_scale1 +
+                output_height_scale2 * output_width_scale2 +
+                output_height_scale3 * output_width_scale3) *
+               static_cast<int>(anchors_.size()) / anchorSizeFactor / numScales;
   }
 
   yolo_blobs_.res_box_blob.reset(
@@ -341,8 +339,8 @@ bool YoloObstacleDetector::Detect(const ObstacleDetectorOptions &options,
 
   /////////////////////////// detection part ///////////////////////////
   inference_->Infer();
-  AINFO << "Network Forward: "
-        << static_cast<double>(timer.Toc()) * 0.001 << "ms";
+  AINFO << "Network Forward: " << static_cast<double>(timer.Toc()) * 0.001
+        << "ms";
   get_objects_gpu(yolo_blobs_, stream_, types_, nms_, yolo_param_.model_param(),
                   light_vis_conf_threshold_, light_swt_conf_threshold_,
                   overlapped_.get(), idx_sm_.get(), &(frame->detected_objects));

modules/planning/scenarios/lane_follow/lane_follow_stage.cc

@@ -285,7 +285,8 @@ void LaneFollowStage::PlanFallbackTrajectory(
   const double min_speed_limit_v =
       reference_line_info->st_graph_data().is_initialized()
           ? reference_line_info->st_graph_data()
-              .speed_limit().GetMinSpeedLimitV()
+                .speed_limit()
+                .GetMinSpeedLimitV()
           : std::numeric_limits<double>::infinity();
   const double curr_speed_distance =
       FLAGS_fallback_total_time *

modules/planning/scenarios/park/pull_over/stage_approach.cc

@@ -76,7 +76,7 @@ Stage::StageStatus PullOverStageApproach::Process(
 
       for (size_t i = path_data.discretized_path().size() - 1; i >= 0; --i) {
         if (path_data.frenet_frame_path().back().s() -
-            path_data.frenet_frame_path()[i].s() <
+                path_data.frenet_frame_path()[i].s() <
             kNumExtraTailBoundPoint * kPathBoundsDeciderResolution) {
           continue;
         }
@@ -106,14 +106,14 @@ Stage::StageStatus PullOverStageApproach::Process(
           {pull_over_status.position().x(), pull_over_status.position().y()},
           &pull_over_sl);
 
-      const double stop_line_s = pull_over_sl.s() -
+      const double stop_line_s =
+          pull_over_sl.s() -
           scenario_config_.s_distance_to_stop_for_open_space_parking();
       const std::string virtual_obstacle_id = "DEST_PULL_OVER_PREPARKING";
       const std::vector<std::string> wait_for_obstacle_ids;
       planning::util::BuildStopDecision(
           virtual_obstacle_id, stop_line_s, 1.0,
-          StopReasonCode::STOP_REASON_PREPARKING,
-          wait_for_obstacle_ids,
+          StopReasonCode::STOP_REASON_PREPARKING, wait_for_obstacle_ids,
           "PULL-OVER-scenario", frame,
           &(frame->mutable_reference_line_info()->front()));
 

modules/planning/scenarios/scenario_manager.cc

@@ -976,8 +976,8 @@ void ScenarioManager::UpdatePlanningContextPullOverScenario(
 
   const auto& pull_over_status =
       PlanningContext::Instance()->planning_status().pull_over();
-  if (pull_over_status.has_position() && pull_over_status.position().has_x()
-      && pull_over_status.position().has_y()) {
+  if (pull_over_status.has_position() && pull_over_status.position().has_x() &&
+      pull_over_status.position().has_y()) {
     const auto& routing = frame.local_view().routing;
     if (routing->routing_request().waypoint_size() >= 2) {
       // keep pull-over stop fence if destination not changed

modules/planning/scenarios/util/util.cc

@@ -73,11 +73,9 @@ PullOverStatus CheckADCPullOver(const ReferenceLineInfo& reference_line_info,
                                 const ScenarioPullOverConfig& scenario_config) {
   const auto& pull_over_status =
       PlanningContext::Instance()->planning_status().pull_over();
-  if (!pull_over_status.is_feasible() ||
-      !pull_over_status.has_position() ||
+  if (!pull_over_status.is_feasible() || !pull_over_status.has_position() ||
       !pull_over_status.position().has_x() ||
-      !pull_over_status.position().has_y() ||
-      !pull_over_status.has_theta()) {
+      !pull_over_status.position().has_y() || !pull_over_status.has_theta()) {
     ADEBUG << "pull_over status not set properly: "
            << pull_over_status.DebugString();
     return UNKNOWN;
@@ -112,16 +110,13 @@ PullOverStatus CheckADCPullOver(const ReferenceLineInfo& reference_line_info,
   const common::math::Vec2d adc_position = {
       common::VehicleStateProvider::Instance()->x(),
       common::VehicleStateProvider::Instance()->y()};
-  const common::math::Vec2d target_position = {
-      pull_over_status.position().x(), pull_over_status.position().y()};
+  const common::math::Vec2d target_position = {pull_over_status.position().x(),
+                                               pull_over_status.position().y()};
 
   const bool position_check = CheckPullOverPositionBySL(
-      reference_line_info, scenario_config,
-      adc_position,
-      common::VehicleStateProvider::Instance()->heading(),
-      target_position,
-      pull_over_status.theta(),
-      true);
+      reference_line_info, scenario_config, adc_position,
+      common::VehicleStateProvider::Instance()->heading(), target_position,
+      pull_over_status.theta(), true);
 
   return position_check ? PARK_COMPLETE : PARK_FAIL;
 }
@@ -135,24 +130,19 @@ PullOverStatus CheckADCPullOverPathPoint(
     const common::PathPoint& path_point) {
   const auto& pull_over_status =
       PlanningContext::Instance()->planning_status().pull_over();
-  if (!pull_over_status.is_feasible() ||
-      !pull_over_status.has_position() ||
+  if (!pull_over_status.is_feasible() || !pull_over_status.has_position() ||
       !pull_over_status.position().has_x() ||
-      !pull_over_status.position().has_y() ||
-      !pull_over_status.has_theta()) {
+      !pull_over_status.position().has_y() || !pull_over_status.has_theta()) {
     ADEBUG << "pull_over status not set properly: "
            << pull_over_status.DebugString();
     return UNKNOWN;
   }
 
-  const common::math::Vec2d target_position = {
-      pull_over_status.position().x(), pull_over_status.position().y()};
+  const common::math::Vec2d target_position = {pull_over_status.position().x(),
+                                               pull_over_status.position().y()};
   const bool position_check = CheckPullOverPositionBySL(
-      reference_line_info, scenario_config,
-      {path_point.x(), path_point.y()},
-      path_point.theta(),
-      target_position,
-      pull_over_status.theta(),
+      reference_line_info, scenario_config, {path_point.x(), path_point.y()},
+      path_point.theta(), target_position, pull_over_status.theta(),
       false);  // check l + theta only
 
   return position_check ? PARK_COMPLETE : PARK_FAIL;
@@ -162,11 +152,9 @@ PullOverStatus CheckADCPullOverOpenSpace(
     const ScenarioPullOverConfig& scenario_config) {
   const auto& pull_over_status =
       PlanningContext::Instance()->planning_status().pull_over();
-  if (!pull_over_status.is_feasible() ||
-      !pull_over_status.has_position() ||
+  if (!pull_over_status.is_feasible() || !pull_over_status.has_position() ||
       !pull_over_status.position().has_x() ||
-      !pull_over_status.position().has_y() ||
-      !pull_over_status.has_theta()) {
+      !pull_over_status.position().has_y() || !pull_over_status.has_theta()) {
     ADEBUG << "pull_over status not set properly: "
            << pull_over_status.DebugString();
     return UNKNOWN;
@@ -175,14 +163,12 @@ PullOverStatus CheckADCPullOverOpenSpace(
   const common::math::Vec2d adc_position = {
       common::VehicleStateProvider::Instance()->x(),
       common::VehicleStateProvider::Instance()->y()};
-  const common::math::Vec2d target_position = {
-      pull_over_status.position().x(), pull_over_status.position().y()};
+  const common::math::Vec2d target_position = {pull_over_status.position().x(),
+                                               pull_over_status.position().y()};
 
   const bool position_check = CheckPullOverPositionByDistance(
-      scenario_config,
-      adc_position,
-      common::VehicleStateProvider::Instance()->heading(),
-      target_position,
+      scenario_config, adc_position,
+      common::VehicleStateProvider::Instance()->heading(), target_position,
       pull_over_status.theta());
 
   return position_check ? PARK_COMPLETE : PARK_FAIL;
@@ -193,8 +179,7 @@ bool CheckPullOverPositionBySL(const ReferenceLineInfo& reference_line_info,
                                const common::math::Vec2d& adc_position,
                                const double adc_theta,
                                const common::math::Vec2d& target_position,
-                               const double target_theta,
-                               const bool check_s) {
+                               const double target_theta, const bool check_s) {
   const auto& reference_line = reference_line_info.reference_line();
   common::SLPoint target_sl;
   reference_line.XYToSL(target_position, &target_sl);
@@ -212,10 +197,10 @@ bool CheckPullOverPositionBySL(const ReferenceLineInfo& reference_line_info,
 
   // check s/l/theta diff
   bool ret = (l_diff <= scenario_config.max_l_error_to_end_point() &&
-      theta_diff <= scenario_config.max_theta_error_to_end_point());
+              theta_diff <= scenario_config.max_theta_error_to_end_point());
   if (check_s) {
     ret = (ret && s_diff >= 0 &&
-        s_diff <= scenario_config.max_s_error_to_end_point());
+           s_diff <= scenario_config.max_s_error_to_end_point());
   }
 
   return ret;
@@ -223,19 +208,17 @@ bool CheckPullOverPositionBySL(const ReferenceLineInfo& reference_line_info,
 
 bool CheckPullOverPositionByDistance(
     const ScenarioPullOverConfig& scenario_config,
-    const common::math::Vec2d& adc_position,
-    const double adc_theta,
-    const common::math::Vec2d& target_position,
-    const double target_theta) {
+    const common::math::Vec2d& adc_position, const double adc_theta,
+    const common::math::Vec2d& target_position, const double target_theta) {
   const double distance_diff = adc_position.DistanceTo(target_position);
   const double theta_diff =
       std::fabs(common::math::NormalizeAngle(target_theta - adc_theta));
-  ADEBUG << "distance_diff[" << distance_diff
-         << "] theta_diff[" << theta_diff << "]";
+  ADEBUG << "distance_diff[" << distance_diff << "] theta_diff[" << theta_diff
+         << "]";
 
   // check distance/theta diff
   return (distance_diff <= scenario_config.max_distance_error_to_end_point() &&
-      theta_diff <= scenario_config.max_theta_error_to_end_point());
+          theta_diff <= scenario_config.max_theta_error_to_end_point());
 }
 
 }  // namespace util

modules/planning/scenarios/util/util.h

@@ -53,15 +53,12 @@ bool CheckPullOverPositionBySL(const ReferenceLineInfo& reference_line_info,
                                const common::math::Vec2d& adc_position,
                                const double adc_theta,
                                const common::math::Vec2d& target_position,
-                               const double target_theta,
-                               const bool check_s);
+                               const double target_theta, const bool check_s);
 
 bool CheckPullOverPositionByDistance(
     const ScenarioPullOverConfig& scenario_config,
-    const common::math::Vec2d& adc_position,
-    const double adc_theta,
-    const common::math::Vec2d& target_position,
-    const double target_theta);
+    const common::math::Vec2d& adc_position, const double adc_theta,
+    const common::math::Vec2d& target_position, const double target_theta);
 
 }  // namespace util
 }  // namespace scenario

modules/planning/tasks/deciders/open_space_decider/open_space_pre_stop_decider.cc

@@ -82,8 +82,7 @@ bool OpenSpacePreStopDecider::CheckPullOverPreStop(
   *target_s = 0.0;
   const auto& pull_over_status =
       PlanningContext::Instance()->planning_status().pull_over();
-  if (pull_over_status.has_position() &&
-      pull_over_status.position().has_x() &&
+  if (pull_over_status.has_position() && pull_over_status.position().has_x() &&
       pull_over_status.position().has_y()) {
     common::SLPoint pull_over_sl;
     const auto& reference_line = reference_line_info->reference_line();

modules/planning/tasks/deciders/open_space_decider/open_space_roi_decider.cc

@@ -763,8 +763,7 @@ bool OpenSpaceRoiDecider::GetPullOverSpot(
       PlanningContext::Instance()->planning_status().pull_over();
   if (!pull_over_status.has_position() ||
       !pull_over_status.position().has_x() ||
-      !pull_over_status.position().has_y() ||
-      !pull_over_status.has_theta()) {
+      !pull_over_status.position().has_y() || !pull_over_status.has_theta()) {
     AERROR << "Pull over position not set in planning context";
     return false;
   }

modules/planning/tasks/deciders/path_bounds_decider/path_bounds_decider.cc

@@ -351,10 +351,9 @@ std::string PathBoundsDecider::GeneratePullOverPathBound(
                                ->mutable_pull_over();
   // If already found a pull-over position, simply check if it's valid.
   if (pull_over_status->is_feasible() && pull_over_status->has_position()) {
-    int curr_idx = IsPointWithinPathBound(reference_line_info,
-                                          pull_over_status->position().x(),
-                                          pull_over_status->position().y(),
-                                          *path_bound);
+    int curr_idx = IsPointWithinPathBound(
+        reference_line_info, pull_over_status->position().x(),
+        pull_over_status->position().y(), *path_bound);
     if (curr_idx >= 0) {
       // Trim path-bound properly.
       while (static_cast<int>(path_bound->size()) - 1 >
@@ -398,9 +397,9 @@ std::string PathBoundsDecider::GeneratePullOverPathBound(
   pull_over_status->set_width_right(
       VehicleConfigHelper::GetConfig().vehicle_param().width() / 2.0);
 
-  ADEBUG << "Pull Over: x[" << pull_over_status->position().x()
-         << "] y[" <<  pull_over_status->position().y()
-         << "] theta[" << pull_over_status->theta() << "]";
+  ADEBUG << "Pull Over: x[" << pull_over_status->position().x() << "] y["
+         << pull_over_status->position().y() << "] theta["
+         << pull_over_status->theta() << "]";
 
   while (static_cast<int>(path_bound->size()) - 1 >
          std::get<3>(pull_over_configuration) + kNumExtraTailBoundPoint) {

modules/planning/tasks/optimizers/piecewise_jerk_path/piecewise_jerk_path_optimizer.cc

@@ -170,7 +170,6 @@ bool PiecewiseJerkPathOptimizer::OptimizePath(
                                         FLAGS_lateral_derivative_bound_default);
   piecewise_jerk_problem.set_dddx_bound(FLAGS_lateral_jerk_bound);
 
-
   /**
   // Experimental code to be tested
   // TODO(all): find the params in vehicle config

modules/planning/tasks/optimizers/piecewise_jerk_path/piecewise_jerk_path_optimizer.h

@@ -55,7 +55,8 @@ class PiecewiseJerkPathOptimizer : public PathOptimizer {
                                       const double start_s) const;
 
   double EstimateJerkBoundary(const double vehicle_speed,
-      const double axis_distance, const double max_steering_rate) const;
+                              const double axis_distance,
+                              const double max_steering_rate) const;
 };
 
 }  // namespace planning

modules/planning/traffic_rules/destination.cc

@@ -84,8 +84,7 @@ int Destination::MakeDecisions(Frame* frame,
   if (FLAGS_enable_scenario_pull_over) {
     const auto& pull_over_status =
         PlanningContext::Instance()->planning_status().pull_over();
-    if (pull_over_status.is_feasible() &&
-        pull_over_status.has_position() &&
+    if (pull_over_status.is_feasible() && pull_over_status.has_position() &&
         pull_over_status.position().has_x() &&
         pull_over_status.position().has_y()) {
       // build stop decision based on pull-over position

modules/prediction/evaluator/vehicle/junction_map_evaluator.cc

@@ -88,9 +88,8 @@ bool JunctionMapEvaluator::Evaluate(Obstacle* obstacle_ptr) {
   for (size_t i = 0; i < feature_values.size(); ++i) {
     junction_exit_mask[0][i] = static_cast<float>(feature_values[i]);
   }
-  torch_inputs.push_back(
-      torch::jit::Tuple::create({img_tensor.to(device_),
-                                 junction_exit_mask.to(device_)}));
+  torch_inputs.push_back(torch::jit::Tuple::create(
+      {img_tensor.to(device_), junction_exit_mask.to(device_)}));
 
   // Compute probability
   std::vector<double> probability;