RssObjectConversion.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2018-2021 Intel Corporation
//
// SPDX-License-Identifier: LGPL-2.1-only
//
// ----------------- END LICENSE BLOCK -----------------------------------
#pragma once
 
#include <ad/map/route/FullRoute.hpp>
#include <ad/rss/map/RssObjectData.hpp>
#include <ad/rss/world/Object.hpp>
#include <memory>
 
namespace ad {
namespace rss {
namespace map {
 
class RssObjectConversion
{
public:
  using Ptr = std::shared_ptr<RssObjectConversion>;
 
  using ConstPtr = std::shared_ptr<RssObjectConversion const>;
 
  explicit RssObjectConversion(RssObjectData const &object_data);
 
  RssObjectConversion(RssObjectData const &object_data,
                      ::ad::rss::world::OccupiedRegionVector const &objectOccupiedRegions);
 
  RssObjectConversion(const RssObjectConversion &other) = default;
 
  RssObjectConversion(RssObjectConversion &&other) = default;
 
  ~RssObjectConversion() = default;
 
  RssObjectConversion &operator=(const RssObjectConversion &other) = delete;
 
  RssObjectConversion &operator=(RssObjectConversion &&other) = delete;
 
  ::ad::rss::world::RssDynamics getRssDynamics() const;
 
  ::ad::rss::world::Object const &getRssObject() const;
 
  ::ad::rss::world::ObjectId getId() const;
 
  static bool calculateConservativeMinStoppingDistance(::ad::rss::world::ObjectId const &object_id,
                                                       ::ad::physics::Speed const &current_speed,
                                                       ::ad::rss::world::RssDynamics const &rss_dynamics,
                                                       ::ad::physics::Distance &conservativeMinStoppingDistance);
  bool calculateConservativeMinStoppingDistance(::ad::physics::Distance &conservativeMinStoppingDistance) const;
 
  void updateSpeedLimit(::ad::physics::Speed const &max_speed_on_acceleration);
 
  void laneIntervalAdded(::ad::map::route::LaneInterval const &lane_interval);
 
  void updateVelocityOnRoute(::ad::map::point::ENUHeading const &route_heading);
 
  bool updateVelocityOnRoute(::ad::map::route::FullRoute const &route);
 
  ::ad::map::match::Object const *getObjectMapMatchedPosition() const
  {
    return mObjectMapMatchedPosition;
  }
 
  bool isOriginalSpeedAcceptable(::ad::physics::Speed const acceptableNegativeSpeed = ::ad::physics::Speed(-0.5)) const;
 
  ::ad::physics::SpeedRange const &getOriginalObjectSpeed() const
  {
    return mOriginalObjectSpeed;
  }
 
  ::ad::physics::Distance getDistanceEstimate(RssObjectConversion::ConstPtr other) const;
 
  ::ad::physics::Distance getVehicleLength() const
  {
    return getRssObject().state.dimension.length;
  }
 
  ::ad::physics::Distance getVehicleWidth() const
  {
    return getRssObject().state.dimension.width;
  }
 
private:
  ::ad::rss::world::Object mRssObject;
  ::ad::map::match::Object const *mObjectMapMatchedPosition;
  ::ad::physics::Speed mMaxSpeedOnAcceleration;
  ::ad::physics::SpeedRange const mOriginalObjectSpeed;
  ::ad::rss::world::RssDynamics const &mRssDynamics;
 
  void initializeRssObject(::ad::rss::world::ObjectId const &object_id,
                           ::ad::rss::world::ObjectType const &object_type,
                           ::ad::rss::world::OccupiedRegionVector const &objectOccupiedRegions,
                           ::ad::map::match::ENUObjectPosition const &objectEnuPosition,
                           ::ad::physics::SpeedRange const &objectSpeed,
                           ::ad::physics::AngularVelocity const &objectYawRate,
                           ::ad::physics::Angle const &objectSteeringAngle);
 
  void addRestrictedOccupiedRegion(::ad::map::match::LaneOccupiedRegion const &laneOccupiedRegion,
                                   ::ad::map::route::LaneInterval const &lane_interval);
};
 
} // namespace map
} // namespace rss
} // namespace ad