semantic_map.h

浏览该文件的文档.

/******************************************************************************
 * Copyright 2019 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 <future>
#include <unordered_map>
 
#include "opencv2/opencv.hpp"
 
#include "cyber/common/macros.h"
#include "modules/common_msgs/prediction_msgs/feature.pb.h"
 
#ifdef __aarch64__
#include "modules/prediction/common/affine_transform.h"
#endif
 
namespace apollo {
namespace prediction {
 
class SemanticMap {
 public:
  SemanticMap();
 
  virtual ~SemanticMap() = default;
 
  void Init();
 
  void RunCurrFrame(
      const std::unordered_map<int, ObstacleHistory>& obstacle_id_history_map);
 
  bool GetMapById(const int obstacle_id, cv::Mat* feature_map);
 
 private:
  cv::Point2i GetTransPoint(const double x, const double y, const double base_x,
                            const double base_y) {
    return cv::Point2i(static_cast<int>((x - base_x) / 0.1),
                       static_cast<int>(2000 - (y - base_y) / 0.1));
  }
 
  void DrawBaseMap(const double x, const double y, const double base_x,
                   const double base_y);
 
  void DrawBaseMapThread();
 
  void DrawRoads(const common::PointENU& center_point, const double base_x,
                 const double base_y,
                 const cv::Scalar& color = cv::Scalar(64, 64, 64));
 
  void DrawJunctions(const common::PointENU& center_point, const double base_x,
                     const double base_y,
                     const cv::Scalar& color = cv::Scalar(128, 128, 128));
 
  void DrawCrosswalks(const common::PointENU& center_point, const double base_x,
                      const double base_y,
                      const cv::Scalar& color = cv::Scalar(192, 192, 192));
 
  void DrawLanes(const common::PointENU& center_point, const double base_x,
                 const double base_y,
                 const cv::Scalar& color = cv::Scalar(255, 255, 255));
 
  cv::Scalar HSVtoRGB(double H = 1.0, double S = 1.0, double V = 1.0);
 
  void DrawRect(const Feature& feature, const cv::Scalar& color,
                const double base_x, const double base_y, cv::Mat* img);
 
  void DrawPoly(const Feature& feature, const cv::Scalar& color,
                const double base_x, const double base_y, cv::Mat* img);
 
  void DrawHistory(const ObstacleHistory& history, const cv::Scalar& color,
                   const double base_x, const double base_y, cv::Mat* img);
 
  // Draw adc trajectory in semantic map
  void DrawADCTrajectory(const cv::Scalar& color, const double base_x,
                         const double base_y, cv::Mat* img);
 
  cv::Mat CropArea(const cv::Mat& input_img, const cv::Point2i& center_point,
                   const double heading);
 
  cv::Mat CropByHistory(const ObstacleHistory& history, const cv::Scalar& color,
                        const double base_x, const double base_y);
 
 private:
  // base_image, base_x, and base_y to be updated by async thread
  cv::Mat base_img_;
  double base_x_ = 0.0;
  double base_y_ = 0.0;
 
  std::mutex draw_base_map_thread_mutex_;
 
  // base_image, base_x, and base_y to be used in the current cycle
  cv::Mat curr_img_;
  double curr_base_x_ = 0.0;
  double curr_base_y_ = 0.0;
 
  std::unordered_map<int, ObstacleHistory> obstacle_id_history_map_;
  Feature ego_feature_;
 
  std::future<void> task_future_;
 
  bool started_drawing_ = false;
 
#ifdef __aarch64__
  AffineTransform affine_transformer_;
#endif
};
 
}  // namespace prediction
}  // namespace apollo