simulation_world_updater.h

浏览该文件的文档.

/******************************************************************************
 * Copyright 2017 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 <memory>
#include <string>
#include <vector>
 
#include <boost/thread/locks.hpp>
#include <boost/thread/shared_mutex.hpp>
 
#include "absl/strings/str_cat.h"
 
#include "modules/common_msgs/task_manager_msgs/task_manager.pb.h"
#include "modules/common_msgs/external_command_msgs/lane_follow_command.pb.h"
#include "modules/common_msgs/external_command_msgs/valet_parking_command.pb.h"
#include "modules/common_msgs/external_command_msgs/action_command.pb.h"
 
#include "cyber/common/log.h"
#include "cyber/cyber.h"
#include "modules/dreamview/backend/common/handlers/websocket_handler.h"
#include "modules/dreamview/backend/common/map_service/map_service.h"
#include "modules/dreamview/backend/perception_camera_updater/perception_camera_updater.h"
#include "modules/dreamview/backend/common/plugins/plugin_manager.h"
#include "modules/common_msgs/localization_msgs/localization.pb.h"
#include "modules/dreamview/backend/simulation_world/simulation_world_service.h"
 
namespace apollo {
namespace dreamview {
 
class SimulationWorldUpdater {
 public:
  SimulationWorldUpdater(WebSocketHandler *websocket, WebSocketHandler *map_ws,
                         WebSocketHandler *camera_ws,
                         WebSocketHandler *plugin_ws,
                         const MapService *map_service,
                         PerceptionCameraUpdater *perception_camera_updater,
                         PluginManager *plugin_manager,
                         bool routing_from_file = false);
 
  void Start();
 
  // Time interval, in milliseconds, between pushing SimulationWorld to
  // frontend.
  static constexpr double kSimWorldTimeIntervalMs = 100;
 
  double LastAdcTimestampSec() { return last_pushed_adc_timestamp_sec_; }
 
 private:
  void OnTimer();
 
  bool ConstructLaneFollowCommand(
      const nlohmann::json &json,
      apollo::external_command::LaneFollowCommand *lane_follow_command);
 
  bool ConstructValetParkingCommand(
      const nlohmann::json &json,
      apollo::external_command::ValetParkingCommand *valet_parking_command);
 
  nlohmann::json GetConstructRoutingRequestJson(const nlohmann::json &start,
                                                const nlohmann::json &end);
 
  bool ConstructLaneWayPoint(const nlohmann::json &point,
                             apollo::routing::LaneWaypoint *laneWayPoint,
                             std::string description);
  bool isProcessRunning(const std::string &process_name);
 
  bool ValidateCoordinate(const nlohmann::json &json);
 
  nlohmann::json CheckRoutingPoint(const nlohmann::json &json);
 
  bool LoadPOI();
  nlohmann::json GetPointJsonFromLaneWaypoint(
      const apollo::routing::LaneWaypoint &waypoint);
 
  bool LoadUserDefinedRoutings(const std::string &file_name,
                               google::protobuf::Message *message);
 
  bool AddDefaultRouting(const nlohmann::json &json);
 
  void RegisterMessageHandlers();
 
  SimulationWorldService sim_world_service_;
  const MapService *map_service_ = nullptr;
  WebSocketHandler *websocket_ = nullptr;
  WebSocketHandler *map_ws_ = nullptr;
  WebSocketHandler *camera_ws_ = nullptr;
  WebSocketHandler *plugin_ws_ = nullptr;
  PerceptionCameraUpdater *perception_camera_updater_ = nullptr;
 
  // End point for requesting default route
  apollo::routing::POI poi_;
 
  // default routings
  apollo::routing::POI default_routings_;
  apollo::routing::Landmark *default_routing_;
 
  // park and go
  apollo::routing::POI park_go_routings_;
 
  // The simulation_world in wire format to be pushed to frontend, which is
  // updated by timer.
  std::string simulation_world_;
  std::string simulation_world_with_planning_data_;
 
  // Received relative map data in wire format.
  std::string relative_map_string_;
 
  // Mutex to protect concurrent access to simulation_world_json_.
  // NOTE: Use boost until we have std version of rwlock support.
  boost::shared_mutex mutex_;
 
  std::unique_ptr<cyber::Timer> timer_;
 
  volatile double last_pushed_adc_timestamp_sec_ = 0.0f;
 
  std::unique_ptr<PluginManager> plugin_manager_;
 
  uint64_t command_id_;
};
 
}  // namespace dreamview
}  // namespace apollo