RssObjectAdapter.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/match/AdMapMatching.hpp>
#include <ad/rss/map/RssObjectAdapterData.hpp>
#include <ad/rss/map/RssObjectData.hpp>
#include <ad/rss/map/RssObjectInstance.hpp>
#include "ad/rss/map/RssAppendRoadBoundariesMode.hpp"
#include "ad/rss/map/RssConstellationConfiguration.hpp"
#include "ad/rss/map/RssRouteList.hpp"
 
namespace ad {
namespace rss {
namespace map {
 
template <class OBJECT_INSTANCE_TYPE> class RssObjectAdapter : public RssObjectAdapterData
{
public:
  typedef std::shared_ptr<RssObjectAdapter> Ptr;
 
  typedef std::shared_ptr<RssObjectAdapter const> ConstPtr;
 
  typedef typename RssObjectInstance<OBJECT_INSTANCE_TYPE>::Ptr ObjectInstancePtr;
  typedef typename RssObjectInstance<OBJECT_INSTANCE_TYPE>::ConstPtr ObjectInstanceConstPtr;
 
  explicit RssObjectAdapter(ObjectInstancePtr const objectInstance)
    : mObjectInstance(objectInstance)
  {
    RssObjectAdapterData::object_type = mObjectInstance->getObjectType();
  }
 
  virtual ~RssObjectAdapter() = default;
 
  ::ad::rss::world::ObjectType getObjectType() const
  {
    return object_type;
  }
 
  typename RssRouteCheckerControl<OBJECT_INSTANCE_TYPE>::Ptr getCheckerControl() const
  {
    return getObjectInstance()->getCheckerControl();
  }
 
  ObjectInstancePtr getObjectInstance() const
  {
    return mObjectInstance;
  }
 
  OBJECT_INSTANCE_TYPE &getObjectInstanceType()
  {
    return getObjectInstance()->getObjectInstanceType();
  }
 
  OBJECT_INSTANCE_TYPE const &getObjectInstanceType() const
  {
    return getObjectInstance()->getObjectInstanceType();
  }
 
  virtual ::ad::rss::world::RssDynamics getDefaultRssDynamics() const
  {
    return getCheckerControl()->getDefaultRssDynamics(object_type, getObjectInstanceType());
  }
 
  ::ad::physics::Dimension3D getDimensions() const override
  {
    ::ad::physics::Dimension3D expanded_dimension = dimension;
    if (getCheckerControl()->getConsiderPositionConfidence())
    {
      expanded_dimension.length += 2.0 * position_confidence_ellipse_half_axis_dimension.length;
      expanded_dimension.width += 2.0 * position_confidence_ellipse_half_axis_dimension.width;
    }
    return expanded_dimension;
  }
 
  virtual ::ad::map::match::Object getMatchedObject(::ad::map::match::AdMapMatching const &mapMatching,
                                                    physics::Distance const sampling_distance) const
  {
    ::ad::map::match::Object matchedObject;
    matchedObject.enu_position.center_point = getCenterPoint();
    matchedObject.enu_position.heading = getHeading();
    matchedObject.enu_position.dimension = getDimensions();
    matchedObject.enu_position.enu_reference_point = ::ad::map::access::getENUReferencePoint();
    matchedObject.map_matched_bounding_box
      = mapMatching.getMapMatchedBoundingBox(matchedObject.enu_position, sampling_distance);
    return matchedObject;
  }
 
  virtual bool isObjectIdUniqueOverTime() const
  {
    return true;
  }
 
protected:
  ObjectInstancePtr mObjectInstance;
};
 
template <class OBJECT_INSTANCE_TYPE> class RssPedestrianAdapter : public virtual RssObjectAdapter<OBJECT_INSTANCE_TYPE>
{
public:
  typedef std::shared_ptr<RssPedestrianAdapter> Ptr;
 
  typedef std::shared_ptr<RssPedestrianAdapter const> ConstPtr;
 
  using typename RssObjectAdapter<OBJECT_INSTANCE_TYPE>::ObjectInstancePtr;
 
  explicit RssPedestrianAdapter(ObjectInstancePtr const objectInstance)
    : RssObjectAdapter<OBJECT_INSTANCE_TYPE>(objectInstance)
  {
  }
 
  virtual ~RssPedestrianAdapter() = default;
};
 
template <class OBJECT_INSTANCE_TYPE>
using RssPedestrianAdapterList = std::vector<typename RssPedestrianAdapter<OBJECT_INSTANCE_TYPE>::Ptr>;
 
template <class OBJECT_INSTANCE_TYPE>
class RssArtificialObjectAdapter : public virtual RssObjectAdapter<OBJECT_INSTANCE_TYPE>
{
public:
  typedef std::shared_ptr<RssArtificialObjectAdapter> Ptr;
 
  typedef std::shared_ptr<RssArtificialObjectAdapter const> ConstPtr;
 
  using typename RssObjectAdapter<OBJECT_INSTANCE_TYPE>::ObjectInstancePtr;
 
  explicit RssArtificialObjectAdapter(RssObjectAdapterData const &objectAdapterData,
                                      ::ad::rss::world::RssDynamics rssDynamics,
                                      typename RssRouteCheckerControl<OBJECT_INSTANCE_TYPE>::Ptr checkerControl)
    : RssObjectAdapter<OBJECT_INSTANCE_TYPE>(
      std::make_shared<RssObjectInstanceDummy<OBJECT_INSTANCE_TYPE>>(objectAdapterData, checkerControl))
    , mRssDynamics(rssDynamics)
  {
    // directly fill the objectAdapterData
    *static_cast<RssObjectAdapterData *>(this) = objectAdapterData;
  }
 
  virtual ~RssArtificialObjectAdapter() = default;
 
  ::ad::rss::world::RssDynamics getDefaultRssDynamics() const override
  {
    return mRssDynamics;
  }
 
protected:
  ::ad::rss::world::RssDynamics const mRssDynamics;
 
  template <class OBJECT_INSTANCE_TYPE_INNER>
  class RssObjectInstanceDummy : public RssObjectInstance<OBJECT_INSTANCE_TYPE_INNER>
  {
  public:
    RssObjectInstanceDummy(RssObjectAdapterData const &objectAdapterData,
                           typename RssRouteCheckerControl<OBJECT_INSTANCE_TYPE_INNER>::Ptr checkerControl)
      : RssObjectInstance<OBJECT_INSTANCE_TYPE_INNER>(mDummyObjectInstanceType, checkerControl)
      , mObjectAdapterData(objectAdapterData)
    {
    }
 
    virtual ~RssObjectInstanceDummy() = default;
 
    ::ad::rss::world::ObjectType getObjectType() const override
    {
      // fallback to the standard RssObjectAdapter function
      return mObjectAdapterData.object_type;
    }
 
    RssObjectAdapterData const &mObjectAdapterData;
    OBJECT_INSTANCE_TYPE_INNER mDummyObjectInstanceType{};
  };
};
 
template <class OBJECT_INSTANCE_TYPE>
using RssArtificialObjectAdapterList = std::vector<typename RssArtificialObjectAdapter<OBJECT_INSTANCE_TYPE>::Ptr>;
 
template <class OBJECT_INSTANCE_TYPE> class RssVehicleAdapter : public virtual RssObjectAdapter<OBJECT_INSTANCE_TYPE>
{
public:
  typedef std::shared_ptr<RssVehicleAdapter> Ptr;
 
  typedef std::shared_ptr<RssVehicleAdapter const> ConstPtr;
 
  using typename RssObjectAdapter<OBJECT_INSTANCE_TYPE>::ObjectInstancePtr;
  using RssObjectAdapter<OBJECT_INSTANCE_TYPE>::getCheckerControl;
  using RssObjectAdapter<OBJECT_INSTANCE_TYPE>::getObjectInstance;
  using RssObjectAdapter<OBJECT_INSTANCE_TYPE>::getObjectInstanceType;
  using RssObjectAdapterData::getObjectId;
 
  RssVehicleAdapter(ObjectInstancePtr const objectInstance)
    : RssObjectAdapter<OBJECT_INSTANCE_TYPE>(objectInstance)
  {
  }
 
  virtual ~RssVehicleAdapter() = default;
 
  virtual ::ad::rss::map::RssRouteList getRoutePredictions() const
  {
    return ::ad::rss::map::RssRouteList();
  }
 
 
  enum class RssRoutingTargetCommand
  {
    None,          
    AppendTargets, 
    ReplaceTargets 
  };
 
  struct RssRoutingTargetOperation
  {
    RssRoutingTargetCommand command{RssRoutingTargetCommand::None};
    ::ad::map::point::ENUPointList routingTargets{};
  };
 
  virtual RssRoutingTargetOperation getRoutingTargetOperation()
  {
    return getCheckerControl()->getCurrentRoutingTargetOperation(getObjectId());
  }
 
  virtual ad::physics::Distance getRoutingTargetReachedDistance() const
  {
    return ad::physics::Distance(3.);
  }
 
  virtual void activeRoutingTargets(::ad::map::point::ENUPointList const &activeRoutingTargets)
  {
    getCheckerControl()->setActiveRoutingTargets(getObjectId(), activeRoutingTargets);
  }
 
  virtual ad::physics::Distance getPositionJumpTraveledDistance() const
  {
    return getCheckerControl()->getPositionJumpTraveledDistance();
  }
 
  virtual ad::physics::Distance getMinimumDistanceToObjectsThatHaveToBeAnalyzed() const
  {
    return getCheckerControl()->getMinimumDistanceToObjectsThatHaveToBeAnalyzed();
  }
};
 
template <class OBJECT_INSTANCE_TYPE>
using RssVehicleAdapterList = std::vector<typename RssVehicleAdapter<OBJECT_INSTANCE_TYPE>::Ptr>;
 
template <class OBJECT_INSTANCE_TYPE>
class RssEgoVehicleAdapter : public virtual RssVehicleAdapter<OBJECT_INSTANCE_TYPE>
{
public:
  typedef std::shared_ptr<RssEgoVehicleAdapter> Ptr;
 
  typedef std::shared_ptr<RssEgoVehicleAdapter const> ConstPtr;
 
  using typename RssObjectAdapter<OBJECT_INSTANCE_TYPE>::ObjectInstancePtr;
  using RssObjectAdapter<OBJECT_INSTANCE_TYPE>::getCheckerControl;
  using RssObjectAdapter<OBJECT_INSTANCE_TYPE>::getObjectInstance;
  using RssObjectAdapter<OBJECT_INSTANCE_TYPE>::getObjectInstanceType;
 
  RssEgoVehicleAdapter(ObjectInstancePtr const objectInstance)
    : RssObjectAdapter<OBJECT_INSTANCE_TYPE>(objectInstance)
    , RssVehicleAdapter<OBJECT_INSTANCE_TYPE>(objectInstance)
  {
  }
 
  virtual ~RssEgoVehicleAdapter() = default;
  virtual ::ad::map::landmark::LandmarkIdSet
  getGreenTrafficLightsOnRoute(::ad::map::route::FullRoute const &route) const
  {
    // the default implementation is independent from route...
    (void)route;
    return getCheckerControl()->getCurrentGreenTrafficLights();
  }
 
  virtual RssAppendRoadBoundariesMode getRoadBoundariesMode(::ad::map::route::FullRoute const &route) const
  {
    // the default implementation is independent from route...
    (void)route;
    return getCheckerControl()->getRoadBoundariesMode();
  }
 
  virtual RssConstellationConfiguration
  getVehicleConstellationOnRoute(RssRoute const &route,
                                 RssObjectData const &egoVehicleObject,
                                 typename RssVehicleAdapter<OBJECT_INSTANCE_TYPE>::ConstPtr otherVehicle,
                                 RssObjectData const &otherVehicleObject) const
  {
    return getCheckerControl()->getVehicleConstellation(
      route, egoVehicleObject, getObjectInstanceType(), otherVehicleObject, otherVehicle->getObjectInstanceType());
  }
 
  virtual RssConstellationConfiguration
  getPedestrianConstellationOnRoute(RssRoute const &route,
                                    RssObjectData const &egoVehicleObject,
                                    typename RssPedestrianAdapter<OBJECT_INSTANCE_TYPE>::ConstPtr pedestrian,
                                    RssObjectData const &pedestrianObject) const
  {
    return getCheckerControl()->getPedestrianConstellation(
      route, egoVehicleObject, getObjectInstanceType(), pedestrianObject, pedestrian->getObjectInstanceType());
  }
 
  virtual RssConstellationConfiguration getArtificialObjectConstellationOnRoute(
    RssRoute const &route,
    RssObjectData const &egoVehicleObject,
    typename RssArtificialObjectAdapter<OBJECT_INSTANCE_TYPE>::ConstPtr artificialObjectAdapter,
    RssObjectData const &artificialObject) const
  {
    (void)artificialObjectAdapter;
    return getCheckerControl()->getArtificialObjectConstellation(
      route, egoVehicleObject, getObjectInstanceType(), artificialObject);
  }
 
  ::ad::rss::world::ObjectType getObjectType() const
  {
    return ::ad::rss::world::ObjectType::EgoVehicle;
  }
 
  ::ad::rss::world::RssDynamics getDefaultRssDynamics() const override
  {
    return getCheckerControl()->getDefaultRssDynamics(::ad::rss::world::ObjectType::EgoVehicle,
                                                      getObjectInstanceType());
  }
};
 
template <class OBJECT_INSTANCE_TYPE>
using RssEgoVehicleAdapterList = std::vector<typename RssEgoVehicleAdapter<OBJECT_INSTANCE_TYPE>::Ptr>;
 
} // namespace map
} // namespace rss
} // namespace ad