RssRouteCheckerData.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 <map>
#include "ad/rss/core/RssCheck.hpp"
#include "ad/rss/map/RssObjectAdapter.hpp"
 
namespace ad {
namespace rss {
namespace map {
 
class RssRouteCheckerObjectData
{
public:
  RssRouteCheckerObjectData() = default;
 
  RssRouteCheckerObjectData(const RssRouteCheckerObjectData &other) = default;
 
  ~RssRouteCheckerObjectData() = default;
 
  RssRouteCheckerObjectData &operator=(const RssRouteCheckerObjectData &other) = default;
 
  bool operator<(RssRouteCheckerObjectData const &other)
  {
    return mRssObjectData.id < other.mRssObjectData.id;
  }
 
  bool mActive{false};
 
  bool mClearObjectHistory{false};
 
  RssObjectData mRssObjectData;
};
 
template <class OBJECT_INSTANCE_TYPE> class RssRouteCheckerPedestrianData : public RssRouteCheckerObjectData
{
public:
  RssRouteCheckerPedestrianData() = default;
 
  RssRouteCheckerPedestrianData(RssRouteCheckerPedestrianData const &other) = default;
 
  ~RssRouteCheckerPedestrianData() = default;
 
  RssRouteCheckerPedestrianData &operator=(const RssRouteCheckerPedestrianData &other) = default;
 
  typedef RssPedestrianAdapter<OBJECT_INSTANCE_TYPE> RssPedestrianAdapterType;
 
  void updateAdapter(typename RssPedestrianAdapterType::Ptr artificialObjectAdapter)
  {
    mPedestrianAdapter = artificialObjectAdapter;
  }
 
  typename RssPedestrianAdapterType::Ptr getAdapter()
  {
    return mPedestrianAdapter;
  }
 
  typename RssPedestrianAdapterType::ConstPtr getAdapter() const
  {
    return mPedestrianAdapter;
  }
 
  using RssRouteCheckerObjectData::mActive;
  using RssRouteCheckerObjectData::mRssObjectData;
 
protected:
  typename RssPedestrianAdapterType::Ptr mPedestrianAdapter;
};
 
template <class OBJECT_INSTANCE_TYPE> class RssRouteCheckerVehicleData : public RssRouteCheckerObjectData
{
public:
  RssRouteCheckerVehicleData() = default;
 
  RssRouteCheckerVehicleData(RssRouteCheckerVehicleData const &other) = default;
 
  ~RssRouteCheckerVehicleData();
 
  RssRouteCheckerVehicleData &operator=(const RssRouteCheckerVehicleData &other) = default;
 
  typedef RssVehicleAdapter<OBJECT_INSTANCE_TYPE> RssVehicleAdapterType;
 
 
  void updateAdapter(typename RssVehicleAdapterType::Ptr vehicleAdapter)
  {
    mVehicleAdapter = vehicleAdapter;
  }
 
  typename RssVehicleAdapterType::Ptr getAdapter()
  {
    return mVehicleAdapter;
  }
 
  typename RssVehicleAdapterType::ConstPtr getAdapter() const
  {
    return mVehicleAdapter;
  }
 
  enum class RouteExtensionMode
  {
    eAllowMultipleRoutes,  
    eAllowOnlySingleRoute, 
    eAllowOnlyTargetRoute  
  };
 
  void updateRoutes(::ad::physics::Distance const routePreviewDistance,
                    ::ad::map::lane::LaneIdSet const &mapAreaLanes,
                    RouteExtensionMode routeExtensionMode = RouteExtensionMode::eAllowMultipleRoutes);
 
  void normalizeAndOrderRoutes();
 
  RouteExtensionMode mRouteExtensionMode;
  RssRouteList mRoutes;
 
  using RssRouteCheckerObjectData::mActive;
  using RssRouteCheckerObjectData::mRssObjectData;
 
  std::vector<::ad::map::point::ENUPoint> mRoutingTargets;
 
protected:
  std::vector<::ad::map::point::ENUPoint> handleRoutingTargets();
 
  std::vector<::ad::map::route::FullRoute> createRoutes(::ad::physics::Distance const routePreviewDistance,
                                                        ::ad::map::lane::LaneIdSet const &mapAreaLanes);
 
  void shortenRoutes();
 
  void extendRoutes(::ad::physics::Distance const routePreviewDistance,
                    std::vector<::ad::map::point::ENUPoint> const &routingTargetsToAppend,
                    ::ad::map::lane::LaneIdSet const &mapAreaLanes);
 
  RssRouteId mNextRouteId{1};
  bool mExternalRoutes{false};
 
  typename RssVehicleAdapterType::Ptr mVehicleAdapter;
};
 
typedef std::map<RssRouteId, ::ad::rss::core::RssCheck::Ptr> RssRouteCheckMap;
 
template <class OBJECT_INSTANCE_TYPE>
class RssRouteCheckerEgoVehicleData : public RssRouteCheckerVehicleData<OBJECT_INSTANCE_TYPE>
{
public:
  RssRouteCheckerEgoVehicleData() = default;
 
  RssRouteCheckerEgoVehicleData(RssRouteCheckerEgoVehicleData const &other) = default;
 
  ~RssRouteCheckerEgoVehicleData() = default;
 
  RssRouteCheckerEgoVehicleData &operator=(const RssRouteCheckerEgoVehicleData &other) = default;
 
  typedef RssEgoVehicleAdapter<OBJECT_INSTANCE_TYPE> RssEgoVehicleAdapterType;
 
  void updateAdapter(typename RssEgoVehicleAdapterType::Ptr egoVehicleAdapter)
  {
    RssRouteCheckerVehicleData<OBJECT_INSTANCE_TYPE>::updateAdapter(egoVehicleAdapter);
    mEgoVehicleAdapter = egoVehicleAdapter;
  }
 
  typename RssEgoVehicleAdapterType::Ptr getAdapter()
  {
    return mEgoVehicleAdapter;
  }
 
  typename RssEgoVehicleAdapterType::ConstPtr getAdapter() const
  {
    return mEgoVehicleAdapter;
  }
 
  void updateVehicleDynamicsOnRoutes();
 
  void evaluateRoutes();
 
  RssRouteCheckMap mRssRouteCheckMap;
 
  using RssRouteCheckerObjectData::mActive;
  using RssRouteCheckerObjectData::mRssObjectData;
  using RssRouteCheckerVehicleData<OBJECT_INSTANCE_TYPE>::mRoutes;
 
protected:
  typename RssEgoVehicleAdapterType::Ptr mEgoVehicleAdapter;
 
  using RssRouteCheckerVehicleData<OBJECT_INSTANCE_TYPE>::mNextRouteId;
  using RssRouteCheckerVehicleData<OBJECT_INSTANCE_TYPE>::mRoutingTargets;
  using RssRouteCheckerVehicleData<OBJECT_INSTANCE_TYPE>::mExternalRoutes;
};
 
template <class OBJECT_INSTANCE_TYPE> class RssRouteCheckerArtificialObjectData : public RssRouteCheckerObjectData
{
public:
  RssRouteCheckerArtificialObjectData() = default;
 
  RssRouteCheckerArtificialObjectData(RssRouteCheckerArtificialObjectData const &other) = default;
 
  ~RssRouteCheckerArtificialObjectData() = default;
 
  RssRouteCheckerArtificialObjectData &operator=(const RssRouteCheckerArtificialObjectData &other) = default;
 
  void updateAdapter(typename RssArtificialObjectAdapter<OBJECT_INSTANCE_TYPE>::Ptr artificialObjectAdapter)
  {
    mArtificialObjectAdapter = artificialObjectAdapter;
  }
 
  typename RssArtificialObjectAdapter<OBJECT_INSTANCE_TYPE>::Ptr getAdapter()
  {
    return mArtificialObjectAdapter;
  }
 
  typename RssArtificialObjectAdapter<OBJECT_INSTANCE_TYPE>::ConstPtr getAdapter() const
  {
    return mArtificialObjectAdapter;
  }
 
protected:
  typename RssArtificialObjectAdapter<OBJECT_INSTANCE_TYPE>::Ptr mArtificialObjectAdapter;
};
 
template <class OBJECT_INSTANCE_TYPE>
using RssRouteCheckerPedestrianDataMap
  = std::map<::ad::rss::world::ObjectId, RssRouteCheckerPedestrianData<OBJECT_INSTANCE_TYPE>>;
 
template <class OBJECT_INSTANCE_TYPE>
using RssRouteCheckerVehicleDataMap
  = std::map<::ad::rss::world::ObjectId, RssRouteCheckerVehicleData<OBJECT_INSTANCE_TYPE>>;
 
template <class OBJECT_INSTANCE_TYPE>
using RssRouteCheckerEgoVehicleDataMap
  = std::map<::ad::rss::world::ObjectId, RssRouteCheckerEgoVehicleData<OBJECT_INSTANCE_TYPE>>;
 
template <class OBJECT_INSTANCE_TYPE>
using RssRouteCheckerArtificialObjectDataMap
  = std::map<::ad::rss::world::ObjectId, RssRouteCheckerArtificialObjectData<OBJECT_INSTANCE_TYPE>>;
 
} // namespace map
} // namespace rss
} // namespace ad
 
#include "ad/rss/map/detail/RssRouteCheckerDataDetail.hpp"