CoreIntersection.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2018-2021 Intel Corporation
//
// SPDX-License-Identifier: MIT
//
// ----------------- END LICENSE BLOCK -----------------------------------
#pragma once
 
#include <map>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
#include "ad/map/lane/Types.hpp"
#include "ad/map/match/Types.hpp"
#include "ad/map/point/Types.hpp"
#include "ad/map/route/RouteOperation.hpp"
 
namespace ad {
namespace map {
namespace intersection {
 
class CoreIntersection;
 
typedef std::shared_ptr<CoreIntersection> CoreIntersectionPtr;
 
typedef std::shared_ptr<CoreIntersection const> CoreIntersectionConstPtr;
 
class CoreIntersection
{
public:
  static bool isLanePartOfAnIntersection(lane::LaneId const laneId);
 
  static bool isRoutePartOfAnIntersection(route::FullRoute const &route);
 
  static bool isIntersectionOnRoute(route::FullRoute const &route);
 
  static bool isRoadSegmentEnteringIntersection(route::RouteIterator const &routeIterator,
                                                route::RoadSegmentList::const_iterator &routePreviousSegmentIter);
 
  bool objectRouteCrossesIntersection(route::FullRoute const &objectRoute) const;
 
  physics::Distance objectDistanceToIntersection(match::Object const &object) const;
 
  bool objectWithinIntersection(match::MapMatchedObjectBoundingBox const &object) const;
 
  lane::LaneIdSet const &internalLanes() const;
 
  lane::LaneIdSet const &entryLanes() const;
 
  point::ParaPointList const &entryParaPoints() const;
 
  lane::LaneIdSet const &exitLanes() const;
 
  point::ParaPointList const &exitParaPoints() const;
 
  point::BoundingSphere const &getBoundingSphere() const
  {
    return mInternalLanesBoundingSphere;
  }
 
  static CoreIntersectionPtr getCoreIntersectionFor(lane::LaneId const &laneId);
 
  static std::vector<CoreIntersectionPtr> getCoreIntersectionsFor(lane::LaneIdSet const &laneIds);
 
  static std::vector<CoreIntersectionPtr> getCoreIntersectionsFor(lane::LaneIdList const &laneIds);
 
  static std::vector<CoreIntersectionPtr> getCoreIntersectionsForMap();
 
  static CoreIntersectionPtr getCoreIntersectionFor(match::MapMatchedPosition const &mapMatchedPosition);
 
  static std::vector<CoreIntersectionPtr> getCoreIntersectionsForInLaneMatches(point::ENUPoint const &position);
 
  static std::vector<CoreIntersectionPtr>
  getCoreIntersectionsForInLaneMatches(match::MapMatchedPositionConfidenceList const &mapMatchedPositionConfidenceList);
 
  static std::vector<CoreIntersectionPtr>
  getCoreIntersectionsForInLaneMatches(match::MapMatchedObjectBoundingBox const &object);
 
protected:
  CoreIntersection() = default;
 
  bool isLanePartOfCoreIntersection(lane::LaneId const laneId) const;
 
  void extractLanesOfCoreIntersection(lane::LaneId const laneId);
 
  enum SuccessorMode
  {
    OwnIntersection,
    AnyIntersection
  };
 
  bool isLanePartOfIntersection(lane::LaneId const laneId, SuccessorMode const successorMode) const;
 
  std::pair<lane::LaneIdSet, lane::LaneIdSet>
  getDirectSuccessorsInLaneDirection(lane::LaneId const laneId, SuccessorMode const successorMode) const;
 
  lane::LaneIdSet getDirectSuccessorsInLaneDirectionWithinIntersection(lane::LaneId const laneId,
                                                                       SuccessorMode const successorMode) const;
 
  lane::LaneIdSet getAllSuccessorsInLaneDirectionWithinIntersection(lane::LaneId const laneId,
                                                                    SuccessorMode const successorMode) const;
 
  lane::LaneIdSet getLaneAndAllSuccessorsInLaneDirectionWithinIntersection(lane::LaneId const laneId,
                                                                           SuccessorMode const successorMode) const;
 
  lane::LaneIdSet getAllReachableOutgoingLanes(lane::LaneId const laneId, SuccessorMode const successorMode) const;
 
  std::pair<lane::LaneIdSet, lane::LaneIdSet>
  getAllReachableInternalAndOutgoingLanes(lane::LaneId const laneId, SuccessorMode const successorMode) const;
 
  point::ParaPoint getEntryParaPointOfExternalLane(lane::LaneId const &laneId) const;
  point::ParaPoint getExitParaPointOfExternalLane(lane::LaneId const &laneId) const;
  point::ParaPoint getEntryParaPointOfInternalLane(lane::LaneId const &laneId) const;
  point::ParaPoint getExitParaPointOfInternalLane(lane::LaneId const &laneId) const;
 
  lane::LaneIdSet mInternalLanes{};
 
  lane::LaneIdSet mEntryLanes{};
 
  point::ParaPointList mEntryParaPoints{};
 
  lane::LaneIdSet mExitLanes{};
 
  point::ParaPointList mExitParaPoints{};
 
  std::map<lane::LaneId, lane::LaneIdSet> mOverlapping;
  std::map<lane::LaneId, lane::LaneIdSet> mSuccessor;
  std::map<lane::LaneId, lane::LaneIdSet> mPredecessor;
 
  point::BoundingSphere mInternalLanesBoundingSphere;
 
private:
  explicit CoreIntersection(lane::LaneId const &laneId);
 
  void checkAndInsertEntryLane(lane::LaneId const laneId);
  void checkAndInsertExitLane(lane::LaneId const laneId);
  void processContactsForLane(lane::Lane const &lane, lane::ContactLane const &contact);
 
  template <typename CONTAINER>
  static std::vector<CoreIntersectionPtr> getCoreIntersectionsForLaneIds(CONTAINER const &laneIds);
};
 
} // namespace intersection
} // namespace map
} // namespace ad
 
namespace std {
 
std::ostream &operator<<(std::ostream &os, ::ad::map::intersection::CoreIntersection const &intersection);
 
static inline std::string to_string(::ad::map::intersection::CoreIntersection const &intersection)
{
  stringstream sstream;
  sstream << intersection;
  return sstream.str();
}
} // namespace std