common, dreamview, map, routing: fixed issues from cppcheck.

modules/common/util/util.cc

@@ -29,14 +29,6 @@ SLPoint MakeSLPoint(const double s, const double l) {
   return sl;
 }
 
-Point3D MakePoint3D(const double x, const double y, const double z) {
-  Point3D point3d;
-  point3d.set_x(x);
-  point3d.set_y(y);
-  point3d.set_z(z);
-  return point3d;
-}
-
 PointENU MakePointENU(const double x, const double y, const double z) {
   PointENU point_enu;
   point_enu.set_x(x);
@@ -86,16 +78,6 @@ PathPoint MakePathPoint(const double x, const double y, const double z,
   path_point.set_ddkappa(ddkappa);
   return path_point;
 }
-TrajectoryPoint MakeTrajectoryPoint(const PathPoint& path_point,
-                                    const double v, const double a,
-                                    const double relative_time) {
-  TrajectoryPoint point;
-  point.mutable_path_point()->CopyFrom(path_point);
-  point.set_v(v);
-  point.set_a(a);
-  point.set_relative_time(relative_time);
-  return point;
-}
 
 double Distance2D(const PathPoint& a, const PathPoint& b) {
   return std::hypot(a.x() - b.x(), a.y() - b.y());

modules/common/util/util.h

@@ -60,8 +60,6 @@ bool IsProtoEqual(const ProtoA& a, const ProtoB& b) {
  */
 SLPoint MakeSLPoint(const double s, const double l);
 
-Point3D MakePoint3D(const double x, const double y, const double z);
-
 PointENU MakePointENU(const double x, const double y, const double z);
 
 PointENU MakePointENU(const math::Vec2d& xy);
@@ -69,17 +67,13 @@ PointENU MakePointENU(const math::Vec2d& xy);
 apollo::perception::Point MakePerceptionPoint(const double x, const double y,
                                               const double z);
 
-SpeedPoint MakeSpeedPoint(const double s, const double t,
-                          const double v, const double a, const double da);
+SpeedPoint MakeSpeedPoint(const double s, const double t, const double v,
+                          const double a, const double da);
 
 PathPoint MakePathPoint(const double x, const double y, const double z,
                         const double theta, const double kappa,
                         const double dkappa, const double ddkappa);
 
-TrajectoryPoint MakeTrajectoryPoint(
-    const PathPoint& path_point, const double v, const double a,
-    const double relative_time);
-
 /**
  * calculate the distance beteween PathPoint a and PathPoint b
  * @param a one path point

modules/dreamview/backend/map/map_service.cc

@@ -67,7 +67,7 @@ void ExtractOverlapIds(const std::vector<MapElementInfoConstPtr> &items,
 }
 
 void ExtractStringVectorFromJson(const nlohmann::json &json_object,
-                                 const std::string key,
+                                 const std::string &key,
                                  std::vector<std::string> *result) {
   auto iter = json_object.find(key);
   if (iter != json_object.end()) {
@@ -255,8 +255,8 @@ bool MapService::GetPointsFromRouting(const RoutingResponse &routing,
   }
 
   constexpr double angle_threshold = 0.1;  // threshold is about 5.72 degree.
-  std::vector<int> sampled_indices = DownsampleByAngle(path.path_points(),
-                                                       angle_threshold);
+  std::vector<int> sampled_indices =
+      DownsampleByAngle(path.path_points(), angle_threshold);
   for (int index : sampled_indices) {
     points->push_back(path.path_points()[index]);
   }

modules/map/hdmap/adapter/xml_parser/lanes_xml_parser.cc

@@ -219,7 +219,9 @@ Status LanesXmlParser::ParseLane(const tinyxml2::XMLElement& xml_node,
   }
 
   // road mark
-  sub_node = sub_node->FirstChildElement("borderType");
+  if (sub_node) {
+    sub_node = sub_node->FirstChildElement("borderType");
+  }
   while (sub_node) {
     PbLaneBoundary* lane_boundary = lane->mutable_right_boundary();
     PbLaneBoundaryTypeType boundary_type;

modules/map/hdmap/hdmap_common.cc

@@ -141,9 +141,9 @@ void LaneInfo::Init() {
     sampled_right_width_.emplace_back(sample.s(), sample.width());
   }
 
-  const double kMinHalfWidth = 1.05;
   if (lane_.has_type()) {
     if (lane_.type() == Lane::CITY_DRIVING) {
+      const double kMinHalfWidth = 1.05;
       for (const auto &p : sampled_left_width_) {
         if (p.second < kMinHalfWidth) {
           AERROR

modules/map/pnc_map/pnc_map.cc

@@ -323,8 +323,6 @@ bool PncMap::TruncateLaneSegments(
     return false;
   }
   const double kRouteEpsilon = 1e-3;
-  std::vector<MapPathPoint> points;
-  std::vector<LaneSegment> lane_segments;
   // Extend the trajectory towards the start of the trajectory.
   if (start_s < 0) {
     const auto &first_segment = segments[0];

modules/routing/graph/topo_node.cc

@@ -20,8 +20,8 @@
 #include <cmath>
 #include <utility>
 
-#include "modules/routing/graph/range_utils.h"
 #include "modules/common/log.h"
+#include "modules/routing/graph/range_utils.h"
 
 namespace apollo {
 namespace routing {
@@ -33,16 +33,12 @@ const double MIN_INTERNAL_FOR_NODE = 0.01;  // in meter
 using ::google::protobuf::RepeatedPtrField;
 
 void ConvertOutRange(const RepeatedPtrField<CurveRange>& range_vec,
-                     double start_s,
-                     double end_s,
-                     std::vector<NodeSRange>* out_range,
-                     int* prefer_index) {
+                     double start_s, double end_s,
+                     std::vector<NodeSRange>* out_range, int* prefer_index) {
   out_range->clear();
-  double s_s = 0.0;
-  double e_s = 0.0;
   for (const auto& c_range : range_vec) {
-    s_s = c_range.start().s();
-    e_s = c_range.end().s();
+    double s_s = c_range.start().s();
+    double e_s = c_range.end().s();
     if (e_s < start_s || s_s > end_s || e_s < s_s) {
       continue;
     }
@@ -66,8 +62,7 @@ void ConvertOutRange(const RepeatedPtrField<CurveRange>& range_vec,
 }  // namespace
 
 bool TopoNode::IsOutRangeEnough(const std::vector<NodeSRange>& range_vec,
-                                double start_s,
-                                double end_s) {
+                                double start_s, double end_s) {
   if (!NodeSRange::IsEnoughForChangeLane(start_s, end_s)) {
     return false;
   }
@@ -119,14 +114,15 @@ void TopoNode::Init() {
   ConvertOutRange(pb_node_.left_out(), start_s_, end_s_,
                   &left_out_sorted_range_, &left_prefer_range_index_);
 
-  is_left_range_enough_ = (left_prefer_range_index_ >= 0) &&
+  is_left_range_enough_ =
+      (left_prefer_range_index_ >= 0) &&
       left_out_sorted_range_[left_prefer_range_index_].IsEnoughForChangeLane();
 
   ConvertOutRange(pb_node_.right_out(), start_s_, end_s_,
                   &right_out_sorted_range_, &right_prefer_range_index_);
   is_right_range_enough_ = (right_prefer_range_index_ >= 0) &&
-      right_out_sorted_range_[right_prefer_range_index_]
-        .IsEnoughForChangeLane();
+                           right_out_sorted_range_[right_prefer_range_index_]
+                               .IsEnoughForChangeLane();
 }
 
 bool TopoNode::FindAnchorPoint() {
@@ -146,8 +142,7 @@ bool TopoNode::FindAnchorPoint() {
   return false;
 }
 
-void TopoNode::SetAnchorPoint(
-    const ::apollo::common::PointENU& anchor_point) {
+void TopoNode::SetAnchorPoint(const ::apollo::common::PointENU& anchor_point) {
   anchor_point_ = anchor_point;
 }
 
@@ -187,13 +182,12 @@ const std::unordered_set<const TopoEdge*>& TopoNode::InFromLeftEdge() const {
   return in_from_left_edge_set_;
 }
 
-const std::unordered_set<const TopoEdge*>& TopoNode::InFromRightEdge()
-    const {
+const std::unordered_set<const TopoEdge*>& TopoNode::InFromRightEdge() const {
   return in_from_right_edge_set_;
 }
 
-const std::unordered_set<const TopoEdge*>&
-TopoNode::InFromLeftOrRightEdge() const {
+const std::unordered_set<const TopoEdge*>& TopoNode::InFromLeftOrRightEdge()
+    const {
   return in_from_left_or_right_edge_set_;
 }
 
@@ -213,8 +207,8 @@ const std::unordered_set<const TopoEdge*>& TopoNode::OutToRightEdge() const {
   return out_to_right_edge_set_;
 }
 
-const std::unordered_set<const TopoEdge*>&
-TopoNode::OutToLeftOrRightEdge() const {
+const std::unordered_set<const TopoEdge*>& TopoNode::OutToLeftOrRightEdge()
+    const {
   return out_to_left_or_right_edge_set_;
 }
 
@@ -250,14 +244,12 @@ bool TopoNode::IsOverlapEnough(const TopoNode* sub_node,
                                const TopoEdge* edge_for_type) const {
   if (edge_for_type->Type() == TET_LEFT) {
     return (is_left_range_enough_ &&
-            IsOutRangeEnough(left_out_sorted_range_,
-                             sub_node->StartS(),
+            IsOutRangeEnough(left_out_sorted_range_, sub_node->StartS(),
                              sub_node->EndS()));
   }
   if (edge_for_type->Type() == TET_RIGHT) {
     return (is_right_range_enough_ &&
-            IsOutRangeEnough(right_out_sorted_range_,
-                             sub_node->StartS(),
+            IsOutRangeEnough(right_out_sorted_range_, sub_node->StartS(),
                              sub_node->EndS()));
   }
   if (edge_for_type->Type() == TET_FORWARD) {
@@ -322,9 +314,8 @@ bool TopoNode::IsOutToSucEdgeValid() const {
   return std::fabs(EndS() - OriginNode()->EndS()) < MIN_INTERNAL_FOR_NODE;
 }
 
-
-TopoEdge::TopoEdge(const Edge& edge,
-                   const TopoNode* from_node, const TopoNode* to_node)
+TopoEdge::TopoEdge(const Edge& edge, const TopoNode* from_node,
+                   const TopoNode* to_node)
     : pb_edge_(edge), from_node_(from_node), to_node_(to_node) {}
 
 TopoEdge::~TopoEdge() {}
@@ -341,9 +332,7 @@ const std::string& TopoEdge::FromLaneId() const {
   return pb_edge_.from_lane_id();
 }
 
-const std::string& TopoEdge::ToLaneId() const {
-  return pb_edge_.to_lane_id();
-}
+const std::string& TopoEdge::ToLaneId() const { return pb_edge_.to_lane_id(); }
 
 TopoEdgeType TopoEdge::Type() const {
   if (pb_edge_.direction_type() == Edge::LEFT) {