birdview_img_feature_renderer.h

浏览该文件的文档.

/******************************************************************************
 * Copyright 2020 The Apollo Authors. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *****************************************************************************/
 
#pragma once
 
#include <string>
#include <utility>
#include <vector>
 
#include "opencv2/opencv.hpp"
 
#include "modules/planning/planning_base/proto/learning_data.pb.h"
#include "modules/planning/planning_base/proto/planning_semantic_map_config.pb.h"
 
#include "cyber/common/macros.h"
#include "modules/common/configs/vehicle_config_helper.h"
 
namespace apollo {
namespace planning {
 
class BirdviewImgFeatureRenderer {
 public:
  virtual ~BirdviewImgFeatureRenderer() = default;
 
  bool Init(const PlanningSemanticMapConfig& config);
 
  bool RenderMultiChannelEnv(const LearningDataFrame& learning_data_frame,
                             cv::Mat* img_feature);
 
  bool RenderBGREnv(const LearningDataFrame& learning_data_frame,
                    cv::Mat* img_feature);
 
  bool RenderCurrentEgoStatus(const LearningDataFrame& learning_data_frame,
                              cv::Mat* img_feature);
 
  bool RenderCurrentEgoPoint(const LearningDataFrame& learning_data_frame,
                             cv::Mat* img_feature);
 
  bool RenderCurrentEgoBox(const LearningDataFrame& learning_data_frame,
                           cv::Mat* img_feature);
 
 private:
  bool LoadRoadMap(const std::string& map_file);
 
  bool LoadSpeedlimitMap(const std::string& map_file);
 
  bool RenderLocalRoadMap(const double ego_current_x,
                          const double ego_current_y,
                          const double ego_current_heading,
                          cv::Mat* img_feature);
 
  bool RenderLocalSpeedlimitMap(const double ego_current_x,
                                const double ego_current_y,
                                const double ego_current_heading,
                                cv::Mat* img_feature);
 
  bool RenderEgoCurrentPoint(cv::Mat* img_feature,
                             const cv::Scalar& gray_scale = cv::Scalar(255),
                             const cv::Scalar& bgr_color = cv::Scalar(255, 255,
                                                                      255));
 
  bool RenderEgoCurrentBox(cv::Mat* img_feature,
                           const cv::Scalar& gray_scale = cv::Scalar(255),
                           const cv::Scalar& bgr_color = cv::Scalar(255, 255,
                                                                    255));
 
  bool RenderEgoPastPoint(
      const LearningDataFrame& learning_data_frame,
      const double current_time_sec, const double ego_current_x,
      const double ego_current_y, const double ego_current_heading,
      cv::Mat* img_feature, const cv::Scalar& gray_scale = cv::Scalar(255),
      const cv::Scalar& bgr_color = cv::Scalar(255, 255, 255));
 
  bool RenderObsPastBox(const LearningDataFrame& learning_data_frame,
                        const double current_time_sec, cv::Mat* img_feature,
                        const cv::Scalar& gray_scale = cv::Scalar(255),
                        const cv::Scalar& bgr_color = cv::Scalar(0, 255, 0));
 
  bool RenderObsFutureBox(const LearningDataFrame& learning_data_frame,
                          const double current_time_sec, cv::Mat* img_feature,
                          const cv::Scalar& gray_scale = cv::Scalar(255),
                          const cv::Scalar& bgr_color = cv::Scalar(0, 0, 255));
 
  bool RenderTrafficLight(
      const LearningDataFrame& learning_data_frame, const double ego_current_x,
      const double ego_current_y, const double ego_current_heading,
      cv::Mat* img_feature, const cv::Scalar& gray_scale = cv::Scalar(255),
      const cv::Scalar& bgr_color = cv::Scalar(255, 255, 255));
 
  bool RenderRouting(const LearningDataFrame& learning_data_frame,
                     const double ego_current_x, const double ego_current_y,
                     const double ego_current_heading, cv::Mat* img_feature,
                     const cv::Scalar& gray_scale = cv::Scalar(255),
                     const cv::Scalar& bgr_color = cv::Scalar(255, 255, 255));
 
  bool CropByPose(const double ego_x, const double ego_y,
                  const double ego_heading, const cv::Mat& base_map,
                  cv::Mat* img_feature);
 
  cv::Point2i GetPointImgIdx(const double local_point_x,
                             const double local_point_y,
                             const int center_point_idx_x,
                             const int center_point_idx_y);
 
  cv::Point2i GetAffinedPointImgIdx(const double point_x, const double point_y,
                                    const double center_x,
                                    const double center_y, const double theta);
 
  std::vector<cv::Point2i> GetAffinedBoxImgIdx(
      const double box_center_x, const double box_center_y,
      const double box_theta,
      const std::vector<std::pair<double, double>>& box_corner_points,
      const double center_x, const double center_y, const double theta);
 
  PlanningSemanticMapConfig config_;
  common::VehicleConfig ego_vehicle_config_;
  cv::Mat base_roadmap_img_;
  cv::Mat base_speedlimit_img_;
  double map_bottom_left_point_x_ = 0.0;
  double map_bottom_left_point_y_ = 0.0;
  cv::Mat ego_cur_point_img_;
  cv::Mat ego_cur_box_img_;
  cv::Mat stacked_ego_cur_status_img_;
 
  DECLARE_SINGLETON(BirdviewImgFeatureRenderer)
};
}  // namespace planning
}  // namespace apollo