ad_rss
Classes | Typedefs | Enumerations | Functions
ad::rss::situation Namespace Reference

namespace situation More...

Classes

struct  RelativePosition
 DataType RelativePosition. More...
 
struct  Situation
 DataType Situation. More...
 
struct  SituationSnapshot
 DataType SituationSnapshot. More...
 
struct  VehicleState
 DataType VehicleState. More...
 
struct  VelocityRange
 DataType VelocityRange. More...
 

Typedefs

typedef uint64_t SituationId
 DataType SituationId. More...
 
typedef std::vector<::ad::rss::situation::SituationSituationVector
 DataType SituationVector. More...
 

Enumerations

enum  LateralRelativePosition : int32_t {
  LateralRelativePosition::AtLeft = 0, LateralRelativePosition::OverlapLeft = 1, LateralRelativePosition::Overlap = 2, LateralRelativePosition::OverlapRight = 3,
  LateralRelativePosition::AtRight = 4
}
 DataType LateralRelativePosition. More...
 
enum  LongitudinalRelativePosition : int32_t {
  LongitudinalRelativePosition::InFront = 0, LongitudinalRelativePosition::OverlapFront = 1, LongitudinalRelativePosition::Overlap = 2, LongitudinalRelativePosition::OverlapBack = 3,
  LongitudinalRelativePosition::AtBack = 4
}
 DataType LongitudinalRelativePosition. More...
 
enum  SituationType : int32_t {
  SituationType::NotRelevant = 0, SituationType::SameDirection = 1, SituationType::OppositeDirection = 2, SituationType::IntersectionEgoHasPriority = 3,
  SituationType::IntersectionObjectHasPriority = 4, SituationType::IntersectionSamePriority = 5, SituationType::Unstructured = 6
}
 DataType SituationType. More...
 

Functions

std::ostream & operator<< (std::ostream &os, LateralRelativePosition const &value)
 standard ostream operator More...
 
std::ostream & operator<< (std::ostream &os, LongitudinalRelativePosition const &value)
 standard ostream operator More...
 
std::ostream & operator<< (std::ostream &os, RelativePosition const &_value)
 standard ostream operator More...
 
std::ostream & operator<< (std::ostream &os, Situation const &_value)
 standard ostream operator More...
 
std::ostream & operator<< (std::ostream &os, SituationSnapshot const &_value)
 standard ostream operator More...
 
std::ostream & operator<< (std::ostream &os, SituationType const &value)
 standard ostream operator More...
 
std::ostream & operator<< (std::ostream &os, VehicleState const &_value)
 standard ostream operator More...
 
std::ostream & operator<< (std::ostream &os, VelocityRange const &_value)
 standard ostream operator More...
 
bool calculateDistanceOffsetInAcceleratedMovement (physics::Speed const speed, physics::Acceleration const acceleration, physics::Duration const duration, physics::Distance &distanceOffset)
 Calculate the distance traveled after a given period of time on a constant accelerated movement. More...
 
bool calculateSpeedInAcceleratedMovement (physics::Speed const speed, physics::Acceleration const acceleration, physics::Duration const duration, physics::Speed &resultingSpeed)
 Calculate the speed after a given period of time on a constant accelerated movement. More...
 
bool calculateStoppingDistance (physics::Speed const currentSpeed, physics::Acceleration const deceleration, physics::Distance &stoppingDistance)
 Calculate the stopping distance for a given speed and deceleration on a constant accelerated movement. More...
 
bool calculateAcceleratedLimitedMovement (physics::Speed const currentSpeed, physics::Speed const maxSpeedOnAcceleration, physics::Acceleration const acceleration, physics::Duration const duration, physics::Speed &resultingSpeed, physics::Distance &distanceOffset)
 Calculate the vehicle speed after a given period of time on a constant accelerated movement. More...
 
bool calculateTimeToCoverDistance (physics::Speed const currentSpeed, physics::Speed const maxSpeedOnAcceleration, physics::Duration const responseTime, physics::Acceleration const aUntilResponseTime, physics::Acceleration const aAfterResponseTime, physics::Distance const distanceToCover, physics::Duration &requiredTime)
 Calculate the time needed to cover a given distance. More...
 
bool calculateSpeedAndDistanceOffset (physics::Duration const duration, physics::Speed const currentSpeed, physics::Duration const responseTime, physics::Speed const maxSpeedOnAcceleration, physics::Acceleration const aUntilReponseTime, physics::Acceleration const aAfterResponseTime, physics::Speed &resultingSpeed, physics::Distance &distanceOffset)
 Calculate the speed and distance offset after a given duration in a two phased limited constant accelerated movement. More...
 
bool calculateTimeToStop (physics::Speed const currentSpeed, physics::Duration const responseTime, physics::Speed const maxSpeedOnAcceleration, physics::Acceleration const aUntilResponseTime, physics::Acceleration const aAfterResponseTime, physics::Duration &stopDuration)
 Calculate the stopping time in a two phased limited constant accelerated movement. More...
 
bool calculateLongitudinalDistanceOffsetAfterStatedBrakingPattern (physics::Speed const &currentLongitudinalSpeed, physics::Speed const &maxSpeedOnAcceleration, physics::Duration const &responseTime, physics::Acceleration const &acceleration, physics::Acceleration const &deceleration, physics::Distance &distanceOffset)
 Calculate the longitudinal distance offset of a vehicle when applying the "stated braking pattern" with given deceleration. More...
 
bool calculateLateralDistanceOffsetAfterStatedBrakingPattern (physics::Speed const &currentLateralSpeed, physics::Duration const &responseTime, physics::Acceleration const &acceleration, physics::Acceleration const &deceleration, physics::Distance &distanceOffset)
 Calculate the lateral distance offset of a vehicle when applying the "stated braking pattern" with given deceleration. More...
 
bool calculateSafeLongitudinalDistanceSameDirection (VehicleState const &leadingVehicle, VehicleState const &followingVehicle, physics::Distance &safeDistance)
 Calculate the "safe longitudinal distance" between the two vehicles, Assuming: Maximum deceleration for leading vehicle, and "stated breaking pattern" for following vehicle. More...
 
bool checkSafeLongitudinalDistanceSameDirection (VehicleState const &leadingVehicle, VehicleState const &followingVehicle, physics::Distance const &vehicleDistance, physics::Distance &safeDistance, bool &isDistanceSafe)
 Check if the longitudinal distance between the two vehicles is safe. Assuming: Maximum deceleration for leading vehicle, and "stated breaking pattern" for following vehicle. More...
 
bool calculateSafeLongitudinalDistanceOppositeDirection (VehicleState const &correctVehicle, VehicleState const &oppositeVehicle, physics::Distance &safeDistance)
 Calculate the safe longitudinal distance between to vehicles driving in opposite direction The calculation will assume that the correctVehicle is on the correct lane and oppositeVehicle on an opposite lane. More...
 
bool checkSafeLongitudinalDistanceOppositeDirection (VehicleState const &correctVehicle, VehicleState const &oppositeVehicle, physics::Distance const &vehicleDistance, physics::Distance &safeDistance, bool &isDistanceSafe)
 Check if the longitudinal distance between to vehicles driving in opposite direction is safe. The check will assume that the correctVehicle is on the correct lane and oppositeVehicle on an opposite lane. More...
 
bool checkStopInFrontIntersection (VehicleState const &vehicle, physics::Distance &safeDistance, bool &isDistanceSafe)
 Check if the vehicle can safely break longitudinaly in front of the intersection. Assuming: Using "stated breaking pattern" for breaking. More...
 
bool calculateSafeLateralDistance (VehicleState const &leftVehicle, VehicleState const &rightVehicle, physics::Distance &safeDistance)
 Calculate the "safe lateral distance" between the two vehicles, Assuming: Both vehicles apply "stated breaking pattern". More...
 
bool checkSafeLateralDistance (VehicleState const &leftVehicle, VehicleState const &rightVehicle, physics::Distance const &vehicleDistance, physics::Distance &safeDistance, bool &isDistanceSafe)
 Check if the lateral distance between to vehicles is safe Assuming: Both vehicles apply "stated breaking pattern". More...
 

Detailed Description

namespace situation

Forward declaration.

Typedef Documentation

◆ SituationId

DataType SituationId.

The unique id of an situation over time.

◆ SituationVector

DataType SituationVector.

A vector of situations.

Enumeration Type Documentation

◆ LateralRelativePosition

DataType LateralRelativePosition.

Enumeration describing the relative lateral position between two objects, a and b, within their situation coordinate system.

Enumerator
AtLeft 

The object a is completely left of object b. This means there is an actual lateral space between them.

OverlapLeft 

The objects overlap. The left border of object a is left of the left border of object b AND the right border of object a is left of the right border of object b.

Overlap 

The objects overlap, but neither the conditions for OverlapLeft nor OverlapRight are applicable.

OverlapRight 

The objects overlap. The left border of object a is right of the left border of object b AND the right border of object a is right of the right border of object b.

AtRight 

The object a is completely right of object b. This means there is an actual lateral space between them.

◆ LongitudinalRelativePosition

DataType LongitudinalRelativePosition.

Enumeration describing the relative longitudinal position between two objects, a and b, within their situation coordinate system.

Enumerator
InFront 

The object a is completely in front of object b. This means there is an actual longitudinal space between them.

OverlapFront 

The objects overlap. The front border of object a is in front of the front border of object b AND the back border of object a is in front of the back border of object b.

Overlap 

The objects overlap, but neither the conditions for OverlapFront nor OverlapBack are applicable.

OverlapBack 

The objects overlap. The front border of object a is at back of the front border of object b AND the back border of object a is at back of the back border of object b.

AtBack 

The object a is completely at back of object b. This means there is an actual longitudinal space between them.

◆ SituationType

enum ad::rss::situation::SituationType : int32_t
strong

DataType SituationType.

Enumeration describing the type of situation.

Enumerator
NotRelevant 

The other vehicle cannot conflict with the ego vehicle. This kind of situations are always considered to be safe. Use this situation state to make the object visible in the result vector to be a known object, but not relevant for RSS (e.g. object in opposite direction, but already passed by).

SameDirection 

Both drive on the same road in the same direction.

OppositeDirection 

Both drive on the same road in the opposite direction.

IntersectionEgoHasPriority 

Both drive on individual roads which intersect at the end. Ego vehicle has priority over object.

IntersectionObjectHasPriority 

Both drive on individual roads which intersect at the end. Object has priority over ego vehicle.

IntersectionSamePriority 

Both drive on individual roads which intersect at the end. Object and ego vehicle have same priority.

Unstructured 

An unstructured scene constellation.

Function Documentation

◆ calculateAcceleratedLimitedMovement()

bool ad::rss::situation::calculateAcceleratedLimitedMovement ( physics::Speed const  currentSpeed,
physics::Speed const  maxSpeedOnAcceleration,
physics::Acceleration const  acceleration,
physics::Duration const  duration,
physics::Speed &  resultingSpeed,
physics::Distance &  distanceOffset 
)

Calculate the vehicle speed after a given period of time on a constant accelerated movement.

The accelerated movement (acceleration>0) is limited: The acceleration stops if the speed reaches a limiting maximum speed. The decelerated movement (acceleration<0) is limited: The deceleration stops if the speed reaches zero. Especially, the vehicle is not starting to drive in reverse direction after standing still (In this case, it's equal to the stopping distance)

Parameters
[in]currentSpeedis the current speed of the vehicle (has to be always positive)
[in]maxSpeedOnAccelerationis the maximum speed of the vehicle (e.g. restricted by a limit) to be considered while accelerating (if acceleration >0) (has to be always positive)
[in]accelerationis the acceleration of the vehicle
[in]durationis the (positive) period of time the vehicle keeps accelerating
[out]resultingSpeedis the resulting speed after duration (resultingSpeed >= 0)
[out]distanceOffsetis the distance offset from the current position (distanceOffset >= 0)
Returns
true on success, false otherwise

◆ calculateDistanceOffsetInAcceleratedMovement()

bool ad::rss::situation::calculateDistanceOffsetInAcceleratedMovement ( physics::Speed const  speed,
physics::Acceleration const  acceleration,
physics::Duration const  duration,
physics::Distance &  distanceOffset 
)

Calculate the distance traveled after a given period of time on a constant accelerated movement.

Parameters
[in]speedis the current speed
[in]accelerationis the acceleration value to be considered
[in]durationis the (positive) period of time the acceleration is performed
[out]distanceOffsetis the distance offset from the current position.
Returns
true on success, false otherwise

◆ calculateLateralDistanceOffsetAfterStatedBrakingPattern()

bool ad::rss::situation::calculateLateralDistanceOffsetAfterStatedBrakingPattern ( physics::Speed const &  currentLateralSpeed,
physics::Duration const &  responseTime,
physics::Acceleration const &  acceleration,
physics::Acceleration const &  deceleration,
physics::Distance &  distanceOffset 
)

Calculate the lateral distance offset of a vehicle when applying the "stated braking pattern" with given deceleration.

Parameters
[in]currentLateralSpeedis the current lateral vehicle speed
[in]responseTimeis the response time of the vehicle
[in]accelerationthe acceleration of the vehicle during responseTime
[in]decelerationis the applied breaking deceleration
[out]distanceOffsetis the distance offset of the vehicle from the current position after "the stated braking pattern"
Returns
true on successful calculation, false otherwise

◆ calculateLongitudinalDistanceOffsetAfterStatedBrakingPattern()

bool ad::rss::situation::calculateLongitudinalDistanceOffsetAfterStatedBrakingPattern ( physics::Speed const &  currentLongitudinalSpeed,
physics::Speed const &  maxSpeedOnAcceleration,
physics::Duration const &  responseTime,
physics::Acceleration const &  acceleration,
physics::Acceleration const &  deceleration,
physics::Distance &  distanceOffset 
)

Calculate the longitudinal distance offset of a vehicle when applying the "stated braking pattern" with given deceleration.

Parameters
[in]currentLongitudinalSpeedis the current longitudinal vehicle speed
[in]maxSpeedOnAccelerationis the maximum vehicle speed to be considered in accelerated movement
[in]responseTimeis the response time of the vehicle
[in]accelerationthe acceleration of the vehicle during responseTime
[in]decelerationis the applied breaking deceleration
[out]distanceOffsetis the distance offset of the vehicle from the current position after "the stated braking pattern"
Returns
true on successful calculation, false otherwise

◆ calculateSafeLateralDistance()

bool ad::rss::situation::calculateSafeLateralDistance ( VehicleState const &  leftVehicle,
VehicleState const &  rightVehicle,
physics::Distance &  safeDistance 
)

Calculate the "safe lateral distance" between the two vehicles, Assuming: Both vehicles apply "stated breaking pattern".


 Left vehicle  -->
     |
     |
     v

     ^
     |
     |
 Right vehicle -->

======================================================

Parameters
[in]leftVehicleis the state of the left vehicle
[in]rightVehicleis the state of the right vehicle
[out]safeDistanceis the calculated safe lateral distance
Returns
true on successful calculation, false otherwise

◆ calculateSafeLongitudinalDistanceOppositeDirection()

bool ad::rss::situation::calculateSafeLongitudinalDistanceOppositeDirection ( VehicleState const &  correctVehicle,
VehicleState const &  oppositeVehicle,
physics::Distance &  safeDistance 
)

Calculate the safe longitudinal distance between to vehicles driving in opposite direction The calculation will assume that the correctVehicle is on the correct lane and oppositeVehicle on an opposite lane.

So calculation for the correctVehicle is performed with brakeMinCorrect and performed with brakeMin for the oppositeVehicle


 correctVehicle --->        <---  oppositeVehicle

======================================================

Parameters
[in]correctVehicleis the state of the vehicle driving in the correct lane
[in]oppositeVehicleis the state of the vehicle driving in the wrong lane
[out]isDistanceSafetrue if the distance is safe, false otherwise
Returns
true on successful calculation, false otherwise

◆ calculateSafeLongitudinalDistanceSameDirection()

bool ad::rss::situation::calculateSafeLongitudinalDistanceSameDirection ( VehicleState const &  leadingVehicle,
VehicleState const &  followingVehicle,
physics::Distance &  safeDistance 
)

Calculate the "safe longitudinal distance" between the two vehicles, Assuming: Maximum deceleration for leading vehicle, and "stated breaking pattern" for following vehicle.


 FollowingVehicle --->          LeadingVehicle --->

======================================================

Parameters
[in]leadingVehicleis the state of the leading vehicle
[in]followingVehicleis the state of the following vehicle
[out]safeDistanceis the calculated safe longitudinal distance
Returns
true on successful calculation, false otherwise

◆ calculateSpeedAndDistanceOffset()

bool ad::rss::situation::calculateSpeedAndDistanceOffset ( physics::Duration const  duration,
physics::Speed const  currentSpeed,
physics::Duration const  responseTime,
physics::Speed const  maxSpeedOnAcceleration,
physics::Acceleration const  aUntilReponseTime,
physics::Acceleration const  aAfterResponseTime,
physics::Speed &  resultingSpeed,
physics::Distance &  distanceOffset 
)

Calculate the speed and distance offset after a given duration in a two phased limited constant accelerated movement.

The function will use two values for acceleration, one until reaching the response time, the second one afterwards.

Parameters
[in]durationthe duration for which the speed gets calculated
[in]currentSpeedstarting velocity
[in]responseTimethe time after which aAfterResponseTime is used instead of aUntilResponseTime as acceleration
[in]maxSpeedOnAccelerationis the maximum speed of the vehicle (has to be always positive) to be considered while accelerating
[in]aUntilResponseTimeacceleration until response time
[in]aAfterResponseTimeacceleration after response time
[out]resultingSpeedresulting speed after duration
[out]distanceOffsetresulting distance

◆ calculateSpeedInAcceleratedMovement()

bool ad::rss::situation::calculateSpeedInAcceleratedMovement ( physics::Speed const  speed,
physics::Acceleration const  acceleration,
physics::Duration const  duration,
physics::Speed &  resultingSpeed 
)

Calculate the speed after a given period of time on a constant accelerated movement.

Parameters
[in]speedis the current speed
[in]accelerationis the acceleration value to be considered
[in]durationis the (positive) period of time the acceleration is performed
[out]resultingSpeedis the resulting speed after duration
Returns
true on success, false otherwise

◆ calculateStoppingDistance()

bool ad::rss::situation::calculateStoppingDistance ( physics::Speed const  currentSpeed,
physics::Acceleration const  deceleration,
physics::Distance &  stoppingDistance 
)

Calculate the stopping distance for a given speed and deceleration on a constant accelerated movement.

Parameters
[in]currentSpeedis the current speed of the vehicle
[in]decelerationis the applied deceleration
[out]stoppingDistanceis the resulting stopping distance The sign of the stoppingDistance equals the sign of the currentSpeed.
Returns
true on success, false if a stop cannot be reached

◆ calculateTimeToCoverDistance()

bool ad::rss::situation::calculateTimeToCoverDistance ( physics::Speed const  currentSpeed,
physics::Speed const  maxSpeedOnAcceleration,
physics::Duration const  responseTime,
physics::Acceleration const  aUntilResponseTime,
physics::Acceleration const  aAfterResponseTime,
physics::Distance const  distanceToCover,
physics::Duration &  requiredTime 
)

Calculate the time needed to cover a given distance.

The function will use two values for acceleration, one until reaching the response time, the second one afterwards. If the distance is not covered when then velocity reaches zero, infinite time will be returned

Parameters
[in]currentSpeedstarting velocity
[in]maxSpeedOnAccelerationis the maximum speed of the vehicle (has to be always positive) to be considered while accelerating
[in]responseTimethe time after which aAfterResponseTime is used instead of aUntilResponseTime as acceleration
[in]aUntilResponseTimeduring response time
[in]aAfterResponseTimeafter response time
[in]distanceToCoverdistance that should be covered
[out]requiredTimetime needed to cover the distance
Returns
true on, success, false otherwise

◆ calculateTimeToStop()

bool ad::rss::situation::calculateTimeToStop ( physics::Speed const  currentSpeed,
physics::Duration const  responseTime,
physics::Speed const  maxSpeedOnAcceleration,
physics::Acceleration const  aUntilResponseTime,
physics::Acceleration const  aAfterResponseTime,
physics::Duration &  stopDuration 
)

Calculate the stopping time in a two phased limited constant accelerated movement.

The function will use two values for acceleration, one until reaching the response time, the second one afterwards.

Parameters
[in]currentSpeedstarting velocity
[in]responseTimethe time after which aAfterResponseTime is used instead of aUntilResponseTime as acceleration
[in]maxSpeedOnAccelerationis the maximum speed of the vehicle (has to be always positive) to be considered while accelerating
[in]aUntilResponseTimeacceleration until response time
[in]aAfterResponseTimeacceleration after response time
[out]stopDurationresulting duration
Returns
true on, success, false otherwise

◆ checkSafeLateralDistance()

bool ad::rss::situation::checkSafeLateralDistance ( VehicleState const &  leftVehicle,
VehicleState const &  rightVehicle,
physics::Distance const &  vehicleDistance,
physics::Distance &  safeDistance,
bool &  isDistanceSafe 
)

Check if the lateral distance between to vehicles is safe Assuming: Both vehicles apply "stated breaking pattern".


 Left vehicle  -->
     |
     |
     v

     ^
     |
     |
 Right vehicle -->

======================================================

Parameters
[in]leftVehicleis the state of the left vehicle
[in]rightVehicleis the state of the right vehicle
[in]vehicleDistancethe (positive) lateral distance between the two vehicles
[out]safeDistanceis the calculated safe lateral distance
[out]isDistanceSafeis true if the distance is safe, false otherwise
Returns
true on successful calculation, false otherwise

◆ checkSafeLongitudinalDistanceOppositeDirection()

bool ad::rss::situation::checkSafeLongitudinalDistanceOppositeDirection ( VehicleState const &  correctVehicle,
VehicleState const &  oppositeVehicle,
physics::Distance const &  vehicleDistance,
physics::Distance &  safeDistance,
bool &  isDistanceSafe 
)

Check if the longitudinal distance between to vehicles driving in opposite direction is safe. The check will assume that the correctVehicle is on the correct lane and oppositeVehicle on an opposite lane.

So check for the correctVehcile is performed with brakeMinCorrect and performed with brakeMin for the oppositeVehicle


 correctVehicle --->        <---  oppositeVehicle

======================================================

Parameters
[in]correctVehicleis the state of the vehicle driving in the correct lane
[in]oppositeVehicleis the state of the vehicle driving in the wrong lane
[in]vehicleDistancethe (positive) longitudinal distance between the two vehicles
[out]safeDistanceis the calculated safe longitudinal distance
[out]isDistanceSafetrue if the distance is safe, false otherwise
Returns
true on successful calculation, false otherwise

◆ checkSafeLongitudinalDistanceSameDirection()

bool ad::rss::situation::checkSafeLongitudinalDistanceSameDirection ( VehicleState const &  leadingVehicle,
VehicleState const &  followingVehicle,
physics::Distance const &  vehicleDistance,
physics::Distance &  safeDistance,
bool &  isDistanceSafe 
)

Check if the longitudinal distance between the two vehicles is safe. Assuming: Maximum deceleration for leading vehicle, and "stated breaking pattern" for following vehicle.


 FollowingVehicle --->          LeadingVehicle --->

======================================================

Parameters
[in]leadingVehicleis the state of the leading vehicle
[in]followingVehicleis the state of the following vehicle
[in]vehicleDistancethe (positive) longitudinal distance between the two vehicles
[out]safeDistanceis the calculated safe longitudinal distance
[out]isDistanceSafetrue if the distance is safe, false otherwise
Returns
true on successful calculation, false otherwise

◆ checkStopInFrontIntersection()

bool ad::rss::situation::checkStopInFrontIntersection ( VehicleState const &  vehicle,
physics::Distance &  safeDistance,
bool &  isDistanceSafe 
)

Check if the vehicle can safely break longitudinaly in front of the intersection. Assuming: Using "stated breaking pattern" for breaking.


 vehicle --->             |  Intersection
                          |

============================== =============== | | | |

Parameters
[in]vehicleis the state of the vehicle
[out]safeDistancethe safe distance according to the stated braking pattern
[out]isDistanceSafetrue if the distance is safe, false otherwise
Returns
true on successful calculation, false otherwise

◆ operator<<() [1/8]

std::ostream& ad::rss::situation::operator<< ( std::ostream &  os,
LateralRelativePosition const &  value 
)
inline

standard ostream operator

Parameters
[in]osThe output stream to write to
[in]valueLateralRelativePosition value
Returns
The stream object.

◆ operator<<() [2/8]

std::ostream& ad::rss::situation::operator<< ( std::ostream &  os,
LongitudinalRelativePosition const &  value 
)
inline

standard ostream operator

Parameters
[in]osThe output stream to write to
[in]valueLongitudinalRelativePosition value
Returns
The stream object.

◆ operator<<() [3/8]

std::ostream& ad::rss::situation::operator<< ( std::ostream &  os,
RelativePosition const &  _value 
)
inline

standard ostream operator

Parameters
[in]osThe output stream to write to
[in]_valueRelativePosition value
Returns
The stream object.

◆ operator<<() [4/8]

std::ostream& ad::rss::situation::operator<< ( std::ostream &  os,
Situation const &  _value 
)
inline

standard ostream operator

Parameters
[in]osThe output stream to write to
[in]_valueSituation value
Returns
The stream object.

◆ operator<<() [5/8]

std::ostream& ad::rss::situation::operator<< ( std::ostream &  os,
SituationSnapshot const &  _value 
)
inline

standard ostream operator

Parameters
[in]osThe output stream to write to
[in]_valueSituationSnapshot value
Returns
The stream object.

◆ operator<<() [6/8]

std::ostream& ad::rss::situation::operator<< ( std::ostream &  os,
SituationType const &  value 
)
inline

standard ostream operator

Parameters
[in]osThe output stream to write to
[in]valueSituationType value
Returns
The stream object.

◆ operator<<() [7/8]

std::ostream& ad::rss::situation::operator<< ( std::ostream &  os,
VehicleState const &  _value 
)
inline

standard ostream operator

Parameters
[in]osThe output stream to write to
[in]_valueVehicleState value
Returns
The stream object.

◆ operator<<() [8/8]

std::ostream& ad::rss::situation::operator<< ( std::ostream &  os,
VelocityRange const &  _value 
)
inline

standard ostream operator

Parameters
[in]osThe output stream to write to
[in]_valueVelocityRange value
Returns
The stream object.