Changed coding style for DiscretizedTrajectory class (#595)

modules/planning/common/planning_data.cc

@@ -66,7 +66,7 @@ bool PlanningData::aggregate(const double time_resolution,
     trajectory_point.set_v(speed_point.v());
     trajectory_point.set_a(speed_point.a());
     trajectory_point.set_relative_time(speed_point.t() + relative_time);
-    trajectory->append_trajectory_point(trajectory_point);
+    trajectory->AppendTrajectoryPoint(trajectory_point);
   }
   return true;
 }

modules/planning/common/trajectory/discretized_trajectory.cc

@@ -37,7 +37,7 @@ DiscretizedTrajectory::DiscretizedTrajectory(
   _trajectory_points = std::move(trajectory_points);
 }
 
-double DiscretizedTrajectory::time_length() const {
+double DiscretizedTrajectory::TimeLength() const {
   if (_trajectory_points.empty()) {
     return 0.0;
   }
@@ -66,7 +66,7 @@ TrajectoryPoint DiscretizedTrajectory::Evaluate(
   return util::interpolate(*(it_lower - 1), *it_lower, relative_time);
 }
 
-TrajectoryPoint DiscretizedTrajectory::evaluate_linear_approximation(
+TrajectoryPoint DiscretizedTrajectory::EvaluateUsingLinearApproximation(
     const double relative_time) const {
   auto comp = [](const TrajectoryPoint& p, const double relative_time) {
     return p.relative_time() < relative_time;
@@ -83,7 +83,7 @@ TrajectoryPoint DiscretizedTrajectory::evaluate_linear_approximation(
                                                 relative_time);
 }
 
-std::uint32_t DiscretizedTrajectory::query_nearest_point(
+std::uint32_t DiscretizedTrajectory::QueryNearestPoint(
     const double relative_time) const {
   auto func = [](const TrajectoryPoint& tp, const double relative_time) {
     return tp.relative_time() < relative_time;
@@ -94,7 +94,7 @@ std::uint32_t DiscretizedTrajectory::query_nearest_point(
   return (std::uint32_t)(it_lower - _trajectory_points.begin());
 }
 
-std::uint32_t DiscretizedTrajectory::query_nearest_point(
+std::uint32_t DiscretizedTrajectory::QueryNearestPoint(
     const common::math::Vec2d& position) const {
   double dist_min = std::numeric_limits<double>::max();
   std::uint32_t index_min = 0;
@@ -112,7 +112,7 @@ std::uint32_t DiscretizedTrajectory::query_nearest_point(
   return index_min;
 }
 
-void DiscretizedTrajectory::append_trajectory_point(
+void DiscretizedTrajectory::AppendTrajectoryPoint(
     const TrajectoryPoint& trajectory_point) {
   if (!_trajectory_points.empty()) {
     CHECK_GT(trajectory_point.relative_time(),
@@ -121,23 +121,23 @@ void DiscretizedTrajectory::append_trajectory_point(
   _trajectory_points.push_back(trajectory_point);
 }
 
-const TrajectoryPoint& DiscretizedTrajectory::trajectory_point_at(
+const TrajectoryPoint& DiscretizedTrajectory::TrajectoryPointAt(
     const std::uint32_t index) const {
-  CHECK_LT(index, num_of_points());
+  CHECK_LT(index, NumOfPoints());
   return _trajectory_points[index];
 }
 
-TrajectoryPoint DiscretizedTrajectory::start_point() const {
+TrajectoryPoint DiscretizedTrajectory::StartPoint() const {
   CHECK(!_trajectory_points.empty());
   return _trajectory_points.front();
 }
 
-TrajectoryPoint DiscretizedTrajectory::end_point() const {
+TrajectoryPoint DiscretizedTrajectory::EndPoint() const {
   CHECK(!_trajectory_points.empty());
   return _trajectory_points.back();
 }
 
-std::uint32_t DiscretizedTrajectory::num_of_points() const {
+std::uint32_t DiscretizedTrajectory::NumOfPoints() const {
   return _trajectory_points.size();
 }
 

modules/planning/common/trajectory/discretized_trajectory.h

@@ -25,6 +25,7 @@
 
 #include "modules/common/math/vec2d.h"
 #include "modules/planning/common/trajectory/trajectory.h"
+#include "glog/logging.h"
 
 namespace apollo {
 namespace planning {
@@ -34,44 +35,52 @@ class DiscretizedTrajectory : public Trajectory {
   DiscretizedTrajectory() = default;
 
   DiscretizedTrajectory(
-      std::vector<apollo::common::TrajectoryPoint> trajectory_points);
+      std::vector<common::TrajectoryPoint> trajectory_points);
 
   virtual ~DiscretizedTrajectory() = default;
 
-  double time_length() const override;
+  double TimeLength() const override;
 
-  apollo::common::TrajectoryPoint Evaluate(
+  common::TrajectoryPoint Evaluate(
       const double relative_time) const override;
 
-  apollo::common::TrajectoryPoint start_point() const override;
+  common::TrajectoryPoint StartPoint() const override;
 
-  apollo::common::TrajectoryPoint end_point() const override;
+  common::TrajectoryPoint EndPoint() const override;
 
-  virtual apollo::common::TrajectoryPoint evaluate_linear_approximation(
+  virtual common::TrajectoryPoint EvaluateUsingLinearApproximation(
       const double relative_time) const;
 
-  virtual uint32_t query_nearest_point(const double relative_time) const;
+  virtual uint32_t QueryNearestPoint(const double relative_time) const;
 
-  virtual uint32_t query_nearest_point(
+  virtual uint32_t QueryNearestPoint(
       const common::math::Vec2d& position) const;
 
-  virtual void append_trajectory_point(
-      const apollo::common::TrajectoryPoint& trajectory_point);
+  virtual void AppendTrajectoryPoint(
+      const common::TrajectoryPoint& trajectory_point);
 
-  const apollo::common::TrajectoryPoint& trajectory_point_at(
+  template <typename Iter>
+  void PrependTrajectoryPoints(Iter begin, Iter end) {
+    if (!_trajectory_points.empty() && begin != end) {
+      CHECK((end - 1)->relative_time() < _trajectory_points.front().relative_time());
+    }
+    _trajectory_points.insert(_trajectory_points.begin(), begin, end);
+  }
+
+  const common::TrajectoryPoint& TrajectoryPointAt(
       const std::uint32_t index) const;
 
-  uint32_t num_of_points() const;
+  uint32_t NumOfPoints() const;
 
   void SetTrajectoryPoints(
-      const std::vector<apollo::common::TrajectoryPoint>& points);
+      const std::vector<common::TrajectoryPoint>& points);
 
-  const std::vector<apollo::common::TrajectoryPoint>& trajectory_points() const;
+  const std::vector<common::TrajectoryPoint>& trajectory_points() const;
 
   virtual void Clear();
 
  protected:
-  std::vector<apollo::common::TrajectoryPoint> _trajectory_points;
+  std::vector<common::TrajectoryPoint> _trajectory_points;
 };
 
 }  // namespace planning

modules/planning/common/trajectory/publishable_trajectory.cc

@@ -33,12 +33,12 @@ TrajectoryPoint PublishableTrajectory::evaluate_absolute_time(
 TrajectoryPoint
 PublishableTrajectory::evaluate_linear_approximation_absolute_time(
     const double abs_time) const {
-  return evaluate_linear_approximation(abs_time - _header_time);
+  return EvaluateUsingLinearApproximation(abs_time - _header_time);
 }
 
 std::uint32_t PublishableTrajectory::query_nearest_point_absolute_time(
     const double abs_time) const {
-  return query_nearest_point(abs_time - _header_time);
+  return QueryNearestPoint(abs_time - _header_time);
 }
 
 double PublishableTrajectory::header_time() const { return _header_time; }

modules/planning/common/trajectory/publishable_trajectory.h

@@ -23,7 +23,6 @@
 
 #include "modules/planning/common/trajectory/discretized_trajectory.h"
 #include "modules/planning/proto/planning.pb.h"
-#include "glog/logging.h"
 
 namespace apollo {
 namespace planning {
@@ -44,14 +43,6 @@ class PublishableTrajectory : public DiscretizedTrajectory {
 
   void set_header_time(const double header_time);
 
-  template <typename Iter>
-  void prepend_trajectory_points(Iter begin, Iter end) {
-    if (!_trajectory_points.empty() && begin != end) {
-      CHECK((end - 1)->relative_time() < _trajectory_points.front().relative_time());
-    }
-    _trajectory_points.insert(_trajectory_points.begin(), begin, end);
-  }
-
   void populate_trajectory_protobuf(ADCTrajectory* trajectory_pb) const;
 
  private:

modules/planning/common/trajectory/trajectory.h

@@ -32,14 +32,14 @@ class Trajectory {
 
   virtual ~Trajectory() = default;
 
-  virtual double time_length() const = 0;
+  virtual double TimeLength() const = 0;
 
-  virtual apollo::common::TrajectoryPoint Evaluate(
+  virtual common::TrajectoryPoint Evaluate(
       const double relative_time) const = 0;
 
-  virtual apollo::common::TrajectoryPoint start_point() const = 0;
+  virtual common::TrajectoryPoint StartPoint() const = 0;
 
-  virtual apollo::common::TrajectoryPoint end_point() const = 0;
+  virtual common::TrajectoryPoint EndPoint() const = 0;
 };
 
 }  // namespace planning

modules/planning/planning.cc

@@ -233,7 +233,7 @@ bool Planning::Plan(const bool is_on_auto_mode, const double current_time_stamp,
     return false;
   }
 
-  publishable_trajectory.prepend_trajectory_points(
+  publishable_trajectory.PrependTrajectoryPoints(
       stitching_trajectory.begin(), stitching_trajectory.end() - 1);
 
   publishable_trajectory.set_header_time(current_time_stamp);

modules/planning/trajectory_stitcher/constraint_checker.cc

@@ -79,9 +79,9 @@ bool ConstraintChecker::valid_trajectory(
     }
   }
 
-  for (std::size_t i = 1; i < trajectory.num_of_points(); ++i) {
-    const auto& p0 = trajectory.trajectory_point_at(i - 1);
-    const auto& p1 = trajectory.trajectory_point_at(i);
+  for (std::size_t i = 1; i < trajectory.NumOfPoints(); ++i) {
+    const auto& p0 = trajectory.TrajectoryPointAt(i - 1);
+    const auto& p1 = trajectory.TrajectoryPointAt(i);
     double t = p0.relative_time();
 
     double dt = p1.relative_time() - p0.relative_time();

modules/planning/trajectory_stitcher/trajectory_stitcher.cc

@@ -58,7 +58,7 @@ TrajectoryStitcher::compute_stitching_trajectory(
     return compute_reinit_stitching_trajectory();
   }
 
-  std::size_t prev_trajectory_size = prev_trajectory.num_of_points();
+  std::size_t prev_trajectory_size = prev_trajectory.NumOfPoints();
 
   if (prev_trajectory_size == 0) {
     AWARN << "Projected trajectory at time [" << prev_trajectory.header_time()
@@ -69,7 +69,7 @@ TrajectoryStitcher::compute_stitching_trajectory(
 
   const double veh_rel_time = current_timestamp - prev_trajectory.header_time();
 
-  std::size_t matched_index = prev_trajectory.query_nearest_point(veh_rel_time);
+  std::size_t matched_index = prev_trajectory.QueryNearestPoint(veh_rel_time);
 
   if (matched_index == prev_trajectory_size) {
     AWARN << "The previous trajectory is not long enough, something is wrong";
@@ -77,12 +77,12 @@ TrajectoryStitcher::compute_stitching_trajectory(
   }
 
   if (matched_index == 0 &&
-      veh_rel_time < prev_trajectory.start_point().relative_time()) {
+      veh_rel_time < prev_trajectory.StartPoint().relative_time()) {
     AWARN << "the previous trajectory doesn't cover current time";
     return compute_reinit_stitching_trajectory();
   }
 
-  auto matched_point = prev_trajectory.trajectory_point_at(matched_index);
+  auto matched_point = prev_trajectory.TrajectoryPointAt(matched_index);
   double position_diff =
       common::math::Vec2d(
           matched_point.path_point().x() - VehicleState::instance()->x(),
@@ -97,14 +97,14 @@ TrajectoryStitcher::compute_stitching_trajectory(
 
   double forward_rel_time = veh_rel_time + planning_cycle_time;
   std::size_t forward_index =
-      prev_trajectory.query_nearest_point(forward_rel_time);
+      prev_trajectory.QueryNearestPoint(forward_rel_time);
 
   std::vector<common::TrajectoryPoint> stitching_trajectory(
       prev_trajectory.trajectory_points().begin() + matched_index,
       prev_trajectory.trajectory_points().begin() + forward_index + 1);
 
   double zero_time =
-      prev_trajectory.trajectory_point_at(matched_index).relative_time();
+      prev_trajectory.TrajectoryPointAt(matched_index).relative_time();
 
   std::for_each(stitching_trajectory.begin(), stitching_trajectory.end(),
                 [&zero_time](common::TrajectoryPoint& tp) {
@@ -112,7 +112,7 @@ TrajectoryStitcher::compute_stitching_trajectory(
                 });
 
   double zero_s =
-      prev_trajectory.trajectory_point_at(forward_index).path_point().s();
+      prev_trajectory.TrajectoryPointAt(forward_index).path_point().s();
   std::for_each(stitching_trajectory.begin(), stitching_trajectory.end(),
                 [&zero_s](common::TrajectoryPoint& tp) {
                   double s = tp.path_point().s();