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::Situation >	SituationVector
	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

typedef uint64_t ad::rss::situation::SituationId

DataType SituationId.

The unique id of an situation over time.

◆ SituationVector

typedef std::vector<::ad::rss::situation::Situation> ad::rss::situation::SituationVector

DataType SituationVector.

A vector of situations.

Enumeration Type Documentation

◆ LateralRelativePosition

enum ad::rss::situation::LateralRelativePosition : int32_t

strong

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

enum ad::rss::situation::LongitudinalRelativePosition : int32_t

strong

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]	currentSpeed	is the current speed of the vehicle (has to be always positive)
[in]	maxSpeedOnAcceleration	is 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]	acceleration	is the acceleration of the vehicle
[in]	duration	is the (positive) period of time the vehicle keeps accelerating
[out]	resultingSpeed	is the resulting speed after duration (resultingSpeed >= 0)
[out]	distanceOffset	is 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]	speed	is the current speed
[in]	acceleration	is the acceleration value to be considered
[in]	duration	is the (positive) period of time the acceleration is performed
[out]	distanceOffset	is 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]	currentLateralSpeed	is the current lateral vehicle speed
[in]	responseTime	is the response time of the vehicle
[in]	acceleration	the acceleration of the vehicle during responseTime
[in]	deceleration	is the applied breaking deceleration
[out]	distanceOffset	is 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]	currentLongitudinalSpeed	is the current longitudinal vehicle speed
[in]	maxSpeedOnAcceleration	is the maximum vehicle speed to be considered in accelerated movement
[in]	responseTime	is the response time of the vehicle
[in]	acceleration	the acceleration of the vehicle during responseTime
[in]	deceleration	is the applied breaking deceleration
[out]	distanceOffset	is 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]	leftVehicle	is the state of the left vehicle
[in]	rightVehicle	is the state of the right vehicle
[out]	safeDistance	is 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]	correctVehicle	is the state of the vehicle driving in the correct lane
[in]	oppositeVehicle	is the state of the vehicle driving in the wrong lane
[out]	isDistanceSafe	true 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]	leadingVehicle	is the state of the leading vehicle
[in]	followingVehicle	is the state of the following vehicle
[out]	safeDistance	is 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]	duration	the duration for which the speed gets calculated
[in]	currentSpeed	starting velocity
[in]	responseTime	the time after which aAfterResponseTime is used instead of aUntilResponseTime as acceleration
[in]	maxSpeedOnAcceleration	is the maximum speed of the vehicle (has to be always positive) to be considered while accelerating
[in]	aUntilResponseTime	acceleration until response time
[in]	aAfterResponseTime	acceleration after response time
[out]	resultingSpeed	resulting speed after duration
[out]	distanceOffset	resulting 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]	speed	is the current speed
[in]	acceleration	is the acceleration value to be considered
[in]	duration	is the (positive) period of time the acceleration is performed
[out]	resultingSpeed	is 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]	currentSpeed	is the current speed of the vehicle
[in]	deceleration	is the applied deceleration
[out]	stoppingDistance	is 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]	currentSpeed	starting velocity
[in]	maxSpeedOnAcceleration	is the maximum speed of the vehicle (has to be always positive) to be considered while accelerating
[in]	responseTime	the time after which aAfterResponseTime is used instead of aUntilResponseTime as acceleration
[in]	aUntilResponseTime	during response time
[in]	aAfterResponseTime	after response time
[in]	distanceToCover	distance that should be covered
[out]	requiredTime	time 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]	currentSpeed	starting velocity
[in]	responseTime	the time after which aAfterResponseTime is used instead of aUntilResponseTime as acceleration
[in]	maxSpeedOnAcceleration	is the maximum speed of the vehicle (has to be always positive) to be considered while accelerating
[in]	aUntilResponseTime	acceleration until response time
[in]	aAfterResponseTime	acceleration after response time
[out]	stopDuration	resulting 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]	leftVehicle	is the state of the left vehicle
[in]	rightVehicle	is the state of the right vehicle
[in]	vehicleDistance	the (positive) lateral distance between the two vehicles
[out]	safeDistance	is the calculated safe lateral distance
[out]	isDistanceSafe	is 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]	correctVehicle	is the state of the vehicle driving in the correct lane
[in]	oppositeVehicle	is the state of the vehicle driving in the wrong lane
[in]	vehicleDistance	the (positive) longitudinal distance between the two vehicles
[out]	safeDistance	is the calculated safe longitudinal distance
[out]	isDistanceSafe	true 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]	leadingVehicle	is the state of the leading vehicle
[in]	followingVehicle	is the state of the following vehicle
[in]	vehicleDistance	the (positive) longitudinal distance between the two vehicles
[out]	safeDistance	is the calculated safe longitudinal distance
[out]	isDistanceSafe	true 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]	vehicle	is the state of the vehicle
[out]	safeDistance	the safe distance according to the stated braking pattern
[out]	isDistanceSafe	true 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]	os	The output stream to write to
[in]	value	LateralRelativePosition 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]	os	The output stream to write to
[in]	value	LongitudinalRelativePosition 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]	os	The output stream to write to
[in]	_value	RelativePosition 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]	os	The output stream to write to
[in]	_value	Situation 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]	os	The output stream to write to
[in]	_value	SituationSnapshot 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]	os	The output stream to write to
[in]	value	SituationType 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]	os	The output stream to write to
[in]	_value	VehicleState 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]	os	The output stream to write to
[in]	_value	VelocityRange value

Returns: The stream object.

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ SituationId

◆ SituationVector

Enumeration Type Documentation

◆ LateralRelativePosition

◆ LongitudinalRelativePosition

◆ SituationType

Function Documentation

◆ calculateAcceleratedLimitedMovement()

◆ calculateDistanceOffsetInAcceleratedMovement()

◆ calculateLateralDistanceOffsetAfterStatedBrakingPattern()

◆ calculateLongitudinalDistanceOffsetAfterStatedBrakingPattern()

◆ calculateSafeLateralDistance()

◆ calculateSafeLongitudinalDistanceOppositeDirection()

◆ calculateSafeLongitudinalDistanceSameDirection()

◆ calculateSpeedAndDistanceOffset()

◆ calculateSpeedInAcceleratedMovement()

◆ calculateStoppingDistance()

◆ calculateTimeToCoverDistance()

◆ calculateTimeToStop()

◆ checkSafeLateralDistance()

◆ checkSafeLongitudinalDistanceOppositeDirection()

◆ checkSafeLongitudinalDistanceSameDirection()

◆ checkStopInFrontIntersection()

◆ operator<<() [1/8]

◆ operator<<() [2/8]

◆ operator<<() [3/8]

◆ operator<<() [4/8]

◆ operator<<() [5/8]

◆ operator<<() [6/8]

◆ operator<<() [7/8]

◆ operator<<() [8/8]