RssWorldModelCreator.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2019-2021 Intel Corporation
//
// SPDX-License-Identifier: LGPL-2.1-only
//
// ----------------- END LICENSE BLOCK -----------------------------------
#pragma once
 
#include <ad/map/geometry/PolygonOperation.hpp>
#include <ad/map/intersection/Intersection.hpp>
#include <ad/map/route/FullRoute.hpp>
#include <ad/rss/structured/RssFormulas.hpp>
#include <ad/rss/world/WorldModel.hpp>
#include "ad/rss/map/RssObjectConversion.hpp"
#include "ad/rss/map/RssWorldModelCreation.hpp"
 
namespace ad {
namespace rss {
namespace map {
 
class RssWorldModelCreator
{
public:
  RssWorldModelCreator(RssRestrictSpeedLimitMode const &restrict_speed_limit_mode,
                       ::ad::map::landmark::LandmarkIdSet const &greenTrafficLights,
                       RssWorldModelCreation &worldModelCreation);
 
  explicit RssWorldModelCreator(RssWorldModelCreation &worldModelCreation);
 
  ~RssWorldModelCreator() = default;
 
  bool appendNotRelevantConstellation(::ad::map::route::FullRoute const &route,
                                      RssObjectConversion::ConstPtr egoObject,
                                      RssObjectConversion::ConstPtr otherObject);
 
  bool appendNonIntersectionConstellation(::ad::map::route::ConnectingRoute const &connectingRoute,
                                          world::ConstellationType const &constellation_type,
                                          RssObjectConversion::ConstPtr egoObject,
                                          RssObjectConversion::ConstPtr otherObject);
 
  bool appendMergingConstellation(::ad::map::route::ConnectingRoute const &connectingRoute,
                                  world::ConstellationType const &constellation_type,
                                  RssObjectConversion::ConstPtr egoObject,
                                  RssObjectConversion::ConstPtr otherObject);
 
  bool appendIntersectionConstellation(::ad::map::intersection::IntersectionPtr intersection,
                                       ::ad::map::route::FullRoute const &egoRoute,
                                       ::ad::map::route::FullRoute const &objectRoute,
                                       ::ad::map::route::FullRoute const &intersectionOtherRoute,
                                       RssObjectConversion::ConstPtr egoObject,
                                       RssObjectConversion::ConstPtr otherObject);
 
  bool appendRoadBoundaryConstellations(::ad::map::route::FullRoute const &egoRoute,
                                        RssObjectConversion::ConstPtr egoObject);
 
  bool appendUnstructuredConstellation(RssObjectConversion::ConstPtr iEgoObject,
                                       RssObjectConversion::ConstPtr iOtherObject);
 
private:
  struct Route
  {
    explicit Route(::ad::map::route::FullRoute const &route_in)
      : route(route_in)
      , min_lane_offset(route_in.min_lane_offset)
      , max_lane_offset(route_in.max_lane_offset)
    {
    }
    Route(::ad::map::route::FullRoute const &route_in,
          ::ad::map::point::ENUHeading const &route_heading_start_in,
          ::ad::map::point::ENUHeading const &route_heading_end_in)
      : route(route_in)
      , min_lane_offset(route_in.min_lane_offset)
      , max_lane_offset(route_in.max_lane_offset)
      , route_heading_available(true)
      , route_heading_start(route_heading_start_in)
      , route_heading_end(route_heading_end_in)
    {
    }
    Route(::ad::map::route::FullRoute const &route_in,
          ::ad::map::route::RouteLaneOffset const min_lane_offset_in,
          ::ad::map::route::RouteLaneOffset const max_lane_offset_in,
          ::ad::map::point::ENUHeading const &route_heading_start_in,
          ::ad::map::point::ENUHeading const &route_heading_end_in)
      : route(route_in)
      , min_lane_offset(min_lane_offset_in)
      , max_lane_offset(max_lane_offset_in)
      , route_heading_available(true)
      , route_heading_start(route_heading_start_in)
      , route_heading_end(route_heading_end_in)
    {
    }
    ::ad::map::route::FullRoute const &route;
    ::ad::map::route::RouteLaneOffset const min_lane_offset;
    ::ad::map::route::RouteLaneOffset const max_lane_offset;
    bool route_heading_available{false};
    ::ad::map::point::ENUHeading const route_heading_start;
    ::ad::map::point::ENUHeading const route_heading_end;
  };
 
  bool createRoadArea(Route const &route,
                      ::ad::map::lane::LaneIdSet const &intersectionLanes,
                      std::vector<RssObjectConversion::Ptr> objects,
                      world::RoadArea &roadArea,
                      std::vector<ad::map::route::RoadSegment> *intersectingArea = nullptr);
 
  bool createNonIntersectionRoadArea(::ad::map::route::FullRoute const &route,
                                     ::ad::map::point::ENUHeading const &route_heading_start,
                                     ::ad::map::point::ENUHeading const &route_heading_end,
                                     std::vector<RssObjectConversion::Ptr> objects,
                                     world::RoadArea &roadArea);
 
  bool createMergingRoadArea(::ad::map::route::FullRoute const &route,
                             ::ad::map::point::ENUHeading const &route_heading_start,
                             ::ad::map::point::ENUHeading const &route_heading_end,
                             RssObjectConversion::Ptr object,
                             world::RoadArea &roadArea);
 
  bool createIntersectionRoadArea(::ad::map::route::FullRoute const &route,
                                  ::ad::map::intersection::IntersectionConstPtr intersection,
                                  RssObjectConversion::Ptr object,
                                  world::RoadArea &roadArea,
                                  std::vector<ad::map::route::RoadSegment> &intersectingArea);
 
  bool appendConstellation(world::ConstellationType const &constellation_type,
                           RssObjectConversion::ConstPtr egoObject,
                           world::RoadArea const &egoRoad,
                           RssObjectConversion::ConstPtr otherObject,
                           world::RoadArea const &intersecting_road);
 
  void extractLaneIntervalsAndPolygon(std::vector<ad::map::route::RoadSegment> const &intersectionArea,
                                      std::vector<ad::map::route::LaneInterval> &intersectionLaneIntervals,
                                      ::ad::geometry::Polygon &polygon);
 
  bool updateExactIntersectionArea(world::RoadArea &roadArea,
                                   std::vector<ad::map::route::LaneInterval> const &originalLaneIntervals,
                                   ad::map::match::LaneOccupiedRegionList const &exactIntersectingRegions);
 
  bool updateExactIntersectionArea(world::RoadArea &roadAreaA,
                                   std::vector<ad::map::route::RoadSegment> const &intersectionAreaA,
                                   world::RoadArea &roadAreaB,
                                   std::vector<ad::map::route::RoadSegment> const &intersectionAreaB);
 
  double mSpeedLimitFactor;
  ::ad::map::landmark::LandmarkIdSet mGreenTrafficLights;
  RssWorldModelCreation &mWorldModelCreation;
};
 
} // namespace map
} // namespace rss
} // namespace ad