Prediction: speed up module by avoiding computing redundant lane points

modules/prediction/common/prediction_gflags.cc

@@ -113,6 +113,8 @@ DEFINE_bool(adjust_velocity_by_obstacle_heading, false,
 DEFINE_bool(adjust_velocity_by_position_shift, false,
             "adjust velocity heading to lane heading");
 DEFINE_double(heading_filter_param, 0.99, "heading filter parameter");
+DEFINE_uint32(max_num_lane_point, 20,
+              "The maximal number of lane points to store");
 
 // Validation checker
 DEFINE_double(centripetal_acc_coeff, 0.5,

modules/prediction/common/prediction_gflags.h

@@ -82,6 +82,7 @@ DECLARE_double(rnn_min_lane_relatice_s);
 DECLARE_bool(adjust_velocity_by_obstacle_heading);
 DECLARE_bool(adjust_velocity_by_position_shift);
 DECLARE_double(heading_filter_param);
+DECLARE_uint32(max_num_lane_point);
 
 // Validation checker
 DECLARE_double(centripetal_acc_coeff);

modules/prediction/container/obstacles/obstacle.cc

@@ -899,7 +899,9 @@ void Obstacle::SetLanePoints(Feature* feature) {
     double start_s = lane_sequence->lane_segment(lane_index).start_s();
     double total_s = 0.0;
     double lane_seg_s = start_s;
-    while (lane_index < lane_sequence->lane_segment_size()) {
+    std::size_t count_point = 0;
+    while (lane_index < lane_sequence->lane_segment_size() &&
+           count_point < FLAGS_max_num_lane_point) {
       if (lane_seg_s > lane_segment->end_s()) {
         start_s = lane_seg_s - lane_segment->end_s();
         lane_seg_s = start_s;
@@ -937,6 +939,7 @@ void Obstacle::SetLanePoints(Feature* feature) {
         lane_point.set_angle_diff(lane_point_angle_diff);
         lane_segment->set_lane_turn_type(PredictionMap::LaneTurnType(lane_id));
         lane_segment->add_lane_point()->CopyFrom(lane_point);
+        ++count_point;
         total_s += FLAGS_target_lane_gap;
         lane_seg_s += FLAGS_target_lane_gap;
       }

modules/prediction/evaluator/vehicle/mlp_evaluator.cc

@@ -54,6 +54,7 @@ void MLPEvaluator::Clear() { obstacle_feature_values_map_.clear(); }
 void MLPEvaluator::Evaluate(Obstacle* obstacle_ptr) {
   Clear();
   CHECK_NOTNULL(obstacle_ptr);
+  CHECK_LE(LANE_FEATURE_SIZE, 4 * FLAGS_max_num_lane_point);
 
   int id = obstacle_ptr->id();
   if (!obstacle_ptr->latest_feature().IsInitialized()) {

modules/prediction/evaluator/vehicle/rnn_evaluator.cc

@@ -243,6 +243,7 @@ int RNNEvaluator::SetupObstacleFeature(
 int RNNEvaluator::SetupLaneFeature(const Feature& feature,
                                    const LaneSequence& lane_sequence,
                                    std::vector<float>* const feature_values) {
+  CHECK_LE(LENGTH_LANE_POINT_SEQUENCE, FLAGS_max_num_lane_point);
   feature_values->clear();
   feature_values->reserve(static_cast<size_t>(DIM_LANE_POINT_FEATURE) *
                           static_cast<size_t>(LENGTH_LANE_POINT_SEQUENCE));