cam_setters.h File Reference

Setter functions for the ETSI ITS CAM (EN) More...

#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

Go to the source code of this file.

Classes
struct	etsi_its_cam_msgs::access::etsi_its_msgs::OneCentimeterHelper< SemiAxisLength, typename >
struct	etsi_its_cam_msgs::access::etsi_its_msgs::OneCentimeterHelper< SemiAxisLength, std::void_t< decltype(SemiAxisLength::ONE_CENTIMETER)> >

Functions
template<typename T1, typename T2>
void	etsi_its_cam_msgs::access::throwIfOutOfRange (const T1 &val, const T2 &min, const T2 &max, const std::string val_desc)
	Throws an exception if a given value is out of a defined range.
void	etsi_its_cam_msgs::access::throwIfNotPresent (const bool is_present, const std::string val_desc)
	Throws an exception if the given value is not present.
uint16_t	etsi_its_cam_msgs::access::etsi_its_msgs::getLeapSecondInsertionsSince2004 (const uint64_t unix_seconds)
	Get the leap second insertions since 2004 for given unix seconds.
void	etsi_its_cam_msgs::access::setTimestampITS (TimestampIts &timestamp_its, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds=etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin() ->second)
	Set the TimestampITS object.
void	etsi_its_cam_msgs::access::setLatitude (Latitude &latitude, const double deg)
	Set the Latitude object.
void	etsi_its_cam_msgs::access::setLongitude (Longitude &longitude, const double deg)
	Set the Longitude object.
void	etsi_its_cam_msgs::access::setAltitudeValue (AltitudeValue &altitude, const double value)
	Set the AltitudeValue object.
void	etsi_its_cam_msgs::access::setAltitude (Altitude &altitude, const double value)
	Set the Altitude object.
void	etsi_its_cam_msgs::access::setSpeedValue (SpeedValue &speed, const double value)
	Set the SpeedValue object.
void	etsi_its_cam_msgs::access::setSpeedConfidence (SpeedConfidence &speed_confidence, const double value)
	Set the Speed Confidence object.
void	etsi_its_cam_msgs::access::setSpeed (Speed &speed, const double value, const double confidence=std::numeric_limits< double >::infinity())
	Set the Speed object.
template<typename AccelerationMagnitudeValue>
void	etsi_its_cam_msgs::access::setAccelerationMagnitudeValue (AccelerationMagnitudeValue &accel_mag_value, const double value)
	Set the Acceleration Magnitude Value object.
template<typename AccelerationConfidence>
void	etsi_its_cam_msgs::access::setAccelerationMagnitudeConfidence (AccelerationConfidence &accel_mag_confidence, const double value)
	Set the AccelerationMagnitude Confidence object.
template<typename AccelerationMagnitude>
void	etsi_its_cam_msgs::access::setAccelerationMagnitude (AccelerationMagnitude &accel_mag, const double value, const double confidence=std::numeric_limits< double >::infinity())
	Set the AccelerationMagnitude object.
template<typename AccelerationConfidence>
void	etsi_its_cam_msgs::access::setAccelerationConfidence (AccelerationConfidence &accel_confidence, const double value)
	Set the Acceleration Confidence object.
template<typename T>
void	etsi_its_cam_msgs::access::setReferencePosition (T &ref_position, const double latitude, const double longitude, const double altitude=AltitudeValue::UNAVAILABLE)
	Sets the reference position in the given ReferencePostion object.
template<typename T>
void	etsi_its_cam_msgs::access::setFromUTMPosition (T &reference_position, const gm::PointStamped &utm_position, const int zone, const bool northp)
	Set the ReferencePosition from a given UTM-Position.
template<typename HeadingValue>
void	etsi_its_cam_msgs::access::setHeadingValue (HeadingValue &heading, const double value)
	Set the HeadingValue object.
template<typename HeadingConfidence>
void	etsi_its_cam_msgs::access::setHeadingConfidence (HeadingConfidence &heading_confidence, const double value)
	Set the Heading Confidence object.
template<typename Heading, typename HeadingConfidence = decltype(Heading::heading_confidence)>
void	etsi_its_cam_msgs::access::setHeadingCDD (Heading &heading, const double value, double confidence=std::numeric_limits< double >::infinity())
	Set the Heading object.
template<typename YawRate, typename YawRateValue = decltype(YawRate::yaw_rate_value), typename YawRateConfidence = decltype(YawRate::yaw_rate_confidence)>
void	etsi_its_cam_msgs::access::setYawRateCDD (YawRate &yaw_rate, const double value, double confidence=std::numeric_limits< double >::infinity())
	Set the Yaw Rate object.
template<typename SemiAxisLength>
void	etsi_its_cam_msgs::access::setSemiAxis (SemiAxisLength &semi_axis_length, const double length)
	Set the Semi Axis length.
template<typename PosConfidenceEllipse>
void	etsi_its_cam_msgs::access::setPosConfidenceEllipse (PosConfidenceEllipse &position_confidence_ellipse, const double semi_major_axis, const double semi_minor_axis, const double orientation)
	Set the Pos Confidence Ellipse object.
std::tuple< double, double, double >	etsi_its_cam_msgs::access::confidenceEllipseFromCovMatrix (const std::array< double, 4 > &covariance_matrix, const double object_heading)
	Gets the values needed to set a confidence ellipse from a covariance matrix.
std::tuple< double, double, double >	etsi_its_cam_msgs::access::confidenceEllipseFromWGSCovMatrix (const std::array< double, 4 > &covariance_matrix)
	Gets the values needed to set a confidence ellipse from a covariance matrix.
template<typename PosConfidenceEllipse>
void	etsi_its_cam_msgs::access::setPosConfidenceEllipse (PosConfidenceEllipse &position_confidence_ellipse, const std::array< double, 4 > &covariance_matrix, const double object_heading)
	Set the Pos Confidence Ellipse object.
template<typename PosConfidenceEllipse>
void	etsi_its_cam_msgs::access::setWGSPosConfidenceEllipse (PosConfidenceEllipse &position_confidence_ellipse, const std::array< double, 4 > &covariance_matrix)
	Set the Pos Confidence Ellipse object.
void	etsi_its_cam_msgs::access::setStationId (StationID &station_id, const uint32_t id_value)
	Set the Station Id object.
void	etsi_its_cam_msgs::access::setItsPduHeader (ItsPduHeader &header, const uint8_t message_id, const uint32_t station_id, const uint8_t protocol_version=0)
	Set the Its Pdu Header object.
void	etsi_its_cam_msgs::access::setStationType (StationType &station_type, const uint8_t value)
	Set the Station Type.
void	etsi_its_cam_msgs::access::setItsPduHeader (CAM &cam, const uint32_t station_id, const uint8_t protocol_version=0)
	Set the ItsPduHeader-object for a CAM.
void	etsi_its_cam_msgs::access::setLongitudinalAccelerationValue (LongitudinalAccelerationValue &accel, const double value)
	Set the LongitudinalAccelerationValue object.
void	etsi_its_cam_msgs::access::setLongitudinalAcceleration (LongitudinalAcceleration &accel, const double value, const double confidence=std::numeric_limits< double >::infinity())
	Set the LongitudinalAcceleration object.
void	etsi_its_cam_msgs::access::setLateralAccelerationValue (LateralAccelerationValue &accel, const double value)
	Set the LateralAccelerationValue object.
void	etsi_its_cam_msgs::access::setLateralAcceleration (LateralAcceleration &accel, const double value, const double confidence=std::numeric_limits< double >::infinity())
	Set the LateralAcceleration object.
template<typename T>
void	etsi_its_cam_msgs::access::setBitString (T &bitstring, const std::vector< bool > &bits)
	Set a Bit String by a vector of bools.
void	etsi_its_cam_msgs::access::setGenerationDeltaTime (GenerationDeltaTime &generation_delta_time, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds=etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin() ->second)
	Set the GenerationDeltaTime-Value.
void	etsi_its_cam_msgs::access::setGenerationDeltaTime (CAM &cam, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds=etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin() ->second)
	Set the Generation Delta Time object.
void	etsi_its_cam_msgs::access::setStationType (CAM &cam, const uint8_t value)
	Set the StationType for a CAM.
void	etsi_its_cam_msgs::access::setHeading (CAM &cam, const double heading_val, const double confidence=std::numeric_limits< double >::infinity())
	Set the Heading for a CAM.
void	etsi_its_cam_msgs::access::setYawRate (CAM &cam, const double yaw_rate_val, const double confidence=std::numeric_limits< double >::infinity())
	Set the Yaw Rate for a CAM.
void	etsi_its_cam_msgs::access::setVehicleWidth (VehicleWidth &vehicle_width, const double value)
	Set the VehicleWidth object.
void	etsi_its_cam_msgs::access::setVehicleLengthValue (VehicleLengthValue &vehicle_length, const double value)
	Set the VehicleLengthValue object.
void	etsi_its_cam_msgs::access::setVehicleLength (VehicleLength &vehicle_length, const double value)
	Set the VehicleLength object.
void	etsi_its_cam_msgs::access::setVehicleDimensions (CAM &cam, const double vehicle_length, const double vehicle_width)
	Set the vehicle dimensions.
void	etsi_its_cam_msgs::access::setSpeed (CAM &cam, const double speed_val, const double confidence=SpeedConfidence::UNAVAILABLE)
	Set the vehicle speed.
void	etsi_its_cam_msgs::access::setLongitudinalAcceleration (CAM &cam, const double lon_accel, const double confidence=std::numeric_limits< double >::infinity())
	Set the longitudinal acceleration.
void	etsi_its_cam_msgs::access::setLateralAcceleration (CAM &cam, const double lat_accel, const double confidence=std::numeric_limits< double >::infinity())
	Set the lateral acceleration.
void	etsi_its_cam_msgs::access::setReferencePosition (CAM &cam, const double latitude, const double longitude, const double altitude=AltitudeValue::UNAVAILABLE)
	Set the ReferencePosition for a CAM.
void	etsi_its_cam_msgs::access::setFromUTMPosition (CAM &cam, const gm::PointStamped &utm_position, const int &zone, const bool &northp)
	Set the ReferencePosition of a CAM from a given UTM-Position.
void	etsi_its_cam_msgs::access::setExteriorLights (ExteriorLights &exterior_lights, const std::vector< bool > &bits)
	Set the Exterior Lights by a vector of bools.
void	etsi_its_cam_msgs::access::setExteriorLights (CAM &cam, const std::vector< bool > &exterior_lights)
	Set the Exterior Lights by using a vector of bools.
void	etsi_its_cam_msgs::access::setAccelerationControl (AccelerationControl &acceleration_control, const std::vector< bool > &bits)
	Set the Acceleration Control by a vector of bools.
void	etsi_its_cam_msgs::access::setDrivingLaneStatus (DrivingLaneStatus &driving_lane_status, const std::vector< bool > &bits)
	Set the Driving Lane Status by a vector of bools.
void	etsi_its_cam_msgs::access::setSpecialTransportType (SpecialTransportType &special_transport_type, const std::vector< bool > &bits)
	Set the Special Transport Type by a vector of bools.
void	etsi_its_cam_msgs::access::setLightBarSirenInUse (LightBarSirenInUse &light_bar_siren_in_use, const std::vector< bool > &bits)
	Set the Lightbar Siren In Use by a vector of bools.
void	etsi_its_cam_msgs::access::setEmergencyPriority (EmergencyPriority &emergency_priority, const std::vector< bool > &bits)
	Set the Emergency Priority by a vector of bools.
void	etsi_its_cam_msgs::access::setRefPosConfidence (CAM &cam, const std::array< double, 4 > &covariance_matrix, const double object_heading)
	Set the confidence of the reference position.
void	etsi_its_cam_msgs::access::setWGSRefPosConfidence (CAM &cam, const std::array< double, 4 > &covariance_matrix)
	Set the confidence of the reference position.

Detailed Description

Setter functions for the ETSI ITS CAM (EN)

Definition in file cam_setters.h.

Function Documentation

confidenceEllipseFromCovMatrix()

std::tuple< double, double, double > etsi_its_cam_msgs::access::confidenceEllipseFromCovMatrix ( const std::array< double, 4 > & covariance_matrix, const double object_heading )

inline

Gets the values needed to set a confidence ellipse from a covariance matrix.

Parameters

covariance_matrix	The four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the object (x = longitudinal, y = lateral)
object_heading	The heading of the object in rad, with respect to WGS84

Returns

std::tuple<double, double, double> semi_major_axis [m], semi_minor_axis [m], orientation [deg], with respect to WGS84

Definition at line 467 of file cam_setters.h.

confidenceEllipseFromWGSCovMatrix()

std::tuple< double, double, double > etsi_its_cam_msgs::access::confidenceEllipseFromWGSCovMatrix ( const std::array< double, 4 > & covariance_matrix )

inline

Gets the values needed to set a confidence ellipse from a covariance matrix.

Parameters

covariance_matrix	The four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the WGS axes (x = North, y = East)
object_heading	The heading of the object in rad, with respect to WGS84

Returns

std::tuple<double, double, double> semi_major_axis [m], semi_minor_axis [m], orientation [deg], with respect to WGS84

Definition at line 508 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

getLeapSecondInsertionsSince2004()

uint16_t etsi_its_cam_msgs::access::etsi_its_msgs::getLeapSecondInsertionsSince2004 ( const uint64_t unix_seconds )

inline

Get the leap second insertions since 2004 for given unix seconds.

Parameters

unix_seconds

the current unix seconds for that the leap second insertions since 2004 shall be provided

Returns

uint16_t the number of leap second insertions since 2004 for unix_seconds

Definition at line 61 of file cam_access.h.

                                  {
#include <etsi_its_msgs_utils/impl/cam/cam_utils.h>
}

setAccelerationConfidence()

template<typename AccelerationConfidence>

void etsi_its_cam_msgs::access::setAccelerationConfidence ( AccelerationConfidence & accel_confidence, const double value )

inline

Set the Acceleration Confidence object.

Parameters

accel_confidence	object to set
value	standard deviation in m/s^2 as decimal number

Definition at line 266 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setAccelerationControl()

void etsi_its_cam_msgs::access::setAccelerationControl ( AccelerationControl & acceleration_control, const std::vector< bool > & bits )

inline

Set the Acceleration Control by a vector of bools.

Parameters

acceleration_control
bits

Definition at line 308 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setAccelerationMagnitude()

template<typename AccelerationMagnitude>

void etsi_its_cam_msgs::access::setAccelerationMagnitude ( AccelerationMagnitude & accel_mag, const double value, const double confidence = std::numeric_limits<double>::infinity() )

inline

Set the AccelerationMagnitude object.

AccelerationConfidence is set to UNAVAILABLE

Parameters

accel_mag	object to set
value	AccelerationMagnitudeValue in m/s^2 as decimal number
confidence	standard deviation in m/s^2 as decimal number (default: infinity, mapping to AccelerationConfidence::UNAVAILABLE)

Definition at line 253 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setAccelerationMagnitudeConfidence()

template<typename AccelerationConfidence>

void etsi_its_cam_msgs::access::setAccelerationMagnitudeConfidence ( AccelerationConfidence & accel_mag_confidence, const double value )

inline

Set the AccelerationMagnitude Confidence object.

Parameters

accel_mag_confidence	object to set
value	standard deviation in m/s^2 as decimal number

Definition at line 233 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setAccelerationMagnitudeValue()

template<typename AccelerationMagnitudeValue>

void etsi_its_cam_msgs::access::setAccelerationMagnitudeValue ( AccelerationMagnitudeValue & accel_mag_value, const double value )

inline

Set the Acceleration Magnitude Value object.

Parameters

accel_mag_value	object to set
value	AccelerationMagnitudeValue in m/s^2 as decimal number

Definition at line 220 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setAltitude()

void etsi_its_cam_msgs::access::setAltitude ( Altitude & altitude, const double value )

inline

Set the Altitude object.

AltitudeConfidence is set to UNAVAILABLE

Parameters

altitude	object to set
value	Altitude value (above the reference ellipsoid surface) in meter as decimal number

Definition at line 166 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setAltitudeValue()

void etsi_its_cam_msgs::access::setAltitudeValue ( AltitudeValue & altitude, const double value )

inline

Set the AltitudeValue object.

Parameters

altitude	object to set
value	AltitudeValue value (above the reference ellipsoid surface) in meter as decimal number

Definition at line 147 of file cam_setters.h.

                                                                                           {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setBitString()

template<typename T>

void etsi_its_cam_msgs::access::setBitString ( T & bitstring, const std::vector< bool > & bits )

inline

Set a Bit String by a vector of bools.

Template Parameters

T

Parameters

bitstring	BitString to set
bits	vector of bools

Definition at line 44 of file cam_setters.h.

                                                                                                     {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

setDrivingLaneStatus()

void etsi_its_cam_msgs::access::setDrivingLaneStatus ( DrivingLaneStatus & driving_lane_status, const std::vector< bool > & bits )

inline

Set the Driving Lane Status by a vector of bools.

Parameters

driving_lane_status
bits

Definition at line 318 of file cam_setters.h.

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {

setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);

}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {

auto accel_val = std::round(value * 1e1);

if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {

accel.value = static_cast<int16_t>(accel_val);

} else if (accel_val < LongitudinalAccelerationValue::MIN) {

accel.value = LongitudinalAccelerationValue::MIN;

} else if (accel_val > LongitudinalAccelerationValue::MAX) {

accel.value = LongitudinalAccelerationValue::MAX - 1;

}

}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {

setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);

setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);

}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {

int64_t accel_val = (int64_t)std::round(value * 1e1);

if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {

accel.value = accel_val;

} else if (accel_val < LateralAccelerationValue::MIN) {

accel.value = LateralAccelerationValue::MIN;

} else if (accel_val > LateralAccelerationValue::MAX) {

accel.value = LateralAccelerationValue::MAX - 1;

}

}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {

setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);

setLateralAccelerationValue(accel.lateral_acceleration_value, value);

}

#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {

// First ensure, that the object has the correct heading by setting its value

double orientation = object_heading * 180 / M_PI; // Convert to degrees

// Normalize to [0, 360)

orientation = std::fmod(orientation + 360, 360);

while (orientation < 0) {

orientation += 360;

}

while (orientation >= 360) {

orientation -= 360;

}

setHeading(cam, orientation);

setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,

covariance_matrix, object_heading);

}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {

setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,

covariance_matrix);

}

} // namespace etsi_its_cam_msgs::access

setEmergencyPriority()

void etsi_its_cam_msgs::access::setEmergencyPriority ( EmergencyPriority & emergency_priority, const std::vector< bool > & bits )

inline

Set the Emergency Priority by a vector of bools.

Parameters

emergency_priority
bits

Definition at line 348 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setExteriorLights() [1/2]

void etsi_its_cam_msgs::access::setExteriorLights ( CAM & cam, const std::vector< bool > & exterior_lights )

inline

Set the Exterior Lights by using a vector of bools.

Parameters

cam	CAM to set the exterior lights
exterior_lights	vector of bools to set the exterior lights

Definition at line 283 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setExteriorLights() [2/2]

void etsi_its_cam_msgs::access::setExteriorLights ( ExteriorLights & exterior_lights, const std::vector< bool > & bits )

inline

Set the Exterior Lights by a vector of bools.

Parameters

exterior_lights
bits

Definition at line 273 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setFromUTMPosition() [1/2]

void etsi_its_cam_msgs::access::setFromUTMPosition ( CAM & cam, const gm::PointStamped & utm_position, const int & zone, const bool & northp )

inline

Set the ReferencePosition of a CAM from a given UTM-Position.

The position is transformed to latitude and longitude by using GeographicLib::UTMUPS The z-Coordinate is directly used as altitude value The frame_id of the given utm_position must be set to 'utm_<zone><N/S>'

Parameters

[out]	cam	CAM for which to set the ReferencePosition
[in]	utm_position	geometry_msgs::PointStamped describing the given utm position
[in]	zone	the UTM zone (zero means UPS) of the given position
[in]	northp	hemisphere (true means north, false means south)

Definition at line 263 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setFromUTMPosition() [2/2]

template<typename T>

void etsi_its_cam_msgs::access::setFromUTMPosition ( T & reference_position, const gm::PointStamped & utm_position, const int zone, const bool northp )

inline

Set the ReferencePosition from a given UTM-Position.

The position is transformed to latitude and longitude by using GeographicLib::UTMUPS The z-Coordinate is directly used as altitude value The frame_id of the given utm_position must be set to 'utm_<zone><N/S>'

Parameters

[out]	reference_position	ReferencePostion or ReferencePositionWithConfidence to set
[in]	utm_position	geometry_msgs::PointStamped describing the given utm position
[in]	zone	the UTM zone (zero means UPS) of the given position
[in]	northp	hemisphere (true means north, false means south)

Definition at line 314 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setGenerationDeltaTime() [1/2]

void etsi_its_cam_msgs::access::setGenerationDeltaTime ( CAM & cam, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second )

inline

Set the Generation Delta Time object.

Parameters

cam	CAM to set the GenerationDeltaTime-Value for
unix_nanosecs	Timestamp in unix-nanoseconds to set the GenerationDeltaTime-Value from
n_leap_seconds	Number of leap seconds since 2004 for the given timestamp (Defaults to the todays number of leap seconds since 2004.)

Definition at line 98 of file cam_setters.h.

setGenerationDeltaTime() [2/2]

void etsi_its_cam_msgs::access::setGenerationDeltaTime ( GenerationDeltaTime & generation_delta_time, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second )

inline

Set the GenerationDeltaTime-Value.

Parameters

generation_delta_time	GenerationDeltaTime to set the GenerationDeltaTime-Value for
unix_nanosecs	Timestamp in unix-nanoseconds to set the GenerationDeltaTime-Value from
n_leap_seconds	Number of leap seconds since 2004 for the given timestamp (Defaults to the todays number of leap seconds since 2004.)

Definition at line 81 of file cam_setters.h.

                                                                                             {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {

setHeading()

void etsi_its_cam_msgs::access::setHeading ( CAM & cam, const double heading_val, const double confidence = std::numeric_limits<double>::infinity() )

inline

Set the Heading for a CAM.

0.0° equals WGS84 North, 90.0° equals WGS84 East, 180.0° equals WGS84 South and 270.0° equals WGS84 West HeadingConfidence is set to UNAVAILABLE

Parameters

cam	CAM to set the ReferencePosition
value	Heading value in degree as decimal number
confidence	standard deviation of heading in degree as decimal number (default: infinity, mapping to HeadingConfidence::UNAVAILABLE)

Definition at line 124 of file cam_setters.h.

                                                                                                                     {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)

setHeadingCDD()

template<typename Heading, typename HeadingConfidence = decltype(Heading::heading_confidence)>

void etsi_its_cam_msgs::access::setHeadingCDD	(	Heading &	heading,
		const double	value,
		double	confidence = std::numeric_limits<double>::infinity() )

Set the Heading object.

0.0° equals WGS84 North, 90.0° equals WGS84 East, 180.0° equals WGS84 South and 270.0° equals WGS84 West HeadingConfidence is set to UNAVAILABLE

Parameters

heading	object to set
value	Heading value in degree as decimal number
confidence	standard deviation of heading in degree as decimal number (default: infinity, mapping to HeadingConfidence::UNAVAILABLE)

Definition at line 373 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setHeadingConfidence()

template<typename HeadingConfidence>

void etsi_its_cam_msgs::access::setHeadingConfidence ( HeadingConfidence & heading_confidence, const double value )

inline

Set the Heading Confidence object.

Parameters

heading_confidence	object to set
value	standard deviation of heading in degree as decimal number

Definition at line 352 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setHeadingValue()

template<typename HeadingValue>

void etsi_its_cam_msgs::access::setHeadingValue ( HeadingValue & heading, const double value )

inline

Set the HeadingValue object.

0.0° equals WGS84 North, 90.0° equals WGS84 East, 180.0° equals WGS84 South and 270.0° equals WGS84 West

Parameters

heading	object to set
value	Heading value in degree as decimal number

Definition at line 339 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setItsPduHeader() [1/2]

void etsi_its_cam_msgs::access::setItsPduHeader ( CAM & cam, const uint32_t station_id, const uint8_t protocol_version = 0 )

inline

Set the ItsPduHeader-object for a CAM.

Parameters

cam	CAM-Message to set the ItsPduHeader
station_id
protocol_version

Definition at line 115 of file cam_setters.h.

setItsPduHeader() [2/2]

void etsi_its_cam_msgs::access::setItsPduHeader ( ItsPduHeader & header, const uint8_t message_id, const uint32_t station_id, const uint8_t protocol_version = 0 )

inline

Set the Its Pdu Header object.

Parameters

header	ItsPduHeader to be set
message_id	ID of the message
station_id
protocol_version

Definition at line 85 of file cam_setters.h.

                                                                                             {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {

setLateralAcceleration() [1/2]

void etsi_its_cam_msgs::access::setLateralAcceleration ( CAM & cam, const double lat_accel, const double confidence = std::numeric_limits<double>::infinity() )

inline

Set the lateral acceleration.

Parameters

cam	CAM to set the acceleration value s
lat_accel	lateral acceleration to set in m/s^2 as decimal number (left is positiv), if not available use 16.1 m/s^2
confidence	standard deviation of the lateral acceleration in m/s^2 as decimal number Default is infinity, mapping to AccelerationConfidence::UNAVAILABLE

Definition at line 227 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setLateralAcceleration() [2/2]

void etsi_its_cam_msgs::access::setLateralAcceleration ( LateralAcceleration & accel, const double value, const double confidence = std::numeric_limits<double>::infinity() )

inline

Set the LateralAcceleration object.

AccelerationConfidence is set to UNAVAILABLE

Parameters

accel	object to set
value	LaterallAccelerationValue in m/s^2 as decimal number (left is positive)
confidence	standard deviation of the lateral acceleration in m/s^2 as decimal number Default is infinity, mapping to AccelerationConfidence::UNAVAILABLE

Definition at line 178 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setLateralAccelerationValue()

void etsi_its_cam_msgs::access::setLateralAccelerationValue ( LateralAccelerationValue & accel, const double value )

inline

Set the LateralAccelerationValue object.

Parameters

accel	object to set
value	LateralAccelerationValue in m/s^2 as decimal number (left is positive)

Definition at line 157 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setLatitude()

void etsi_its_cam_msgs::access::setLatitude ( Latitude & latitude, const double deg )

inline

Set the Latitude object.

Parameters

latitude	object to set
deg	Latitude value in degree as decimal number

Definition at line 123 of file cam_setters.h.

                                                                                                                     {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)

setLightBarSirenInUse()

void etsi_its_cam_msgs::access::setLightBarSirenInUse ( LightBarSirenInUse & light_bar_siren_in_use, const std::vector< bool > & bits )

inline

Set the Lightbar Siren In Use by a vector of bools.

Parameters

light_bar_siren_in_use
bits

Definition at line 338 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setLongitude()

void etsi_its_cam_msgs::access::setLongitude ( Longitude & longitude, const double deg )

inline

Set the Longitude object.

Parameters

longitude	object to set
deg	Longitude value in degree as decimal number

Definition at line 135 of file cam_setters.h.

setLongitudinalAcceleration() [1/2]

void etsi_its_cam_msgs::access::setLongitudinalAcceleration ( CAM & cam, const double lon_accel, const double confidence = std::numeric_limits<double>::infinity() )

inline

Set the longitudinal acceleration.

Parameters

cam	CAM to set the acceleration value s
lon_accel	longitudinal acceleration to set in m/s^2 as decimal number (braking is negative), if not available use 16.1 m/s^2
confidence	standard deviation of the longitudinal acceleration in m/s^2 as decimal number Default is infinity, mapping to AccelerationConfidence::UNAVAILABLE

Definition at line 213 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setLongitudinalAcceleration() [2/2]

void etsi_its_cam_msgs::access::setLongitudinalAcceleration ( LongitudinalAcceleration & accel, const double value, const double confidence = std::numeric_limits<double>::infinity() )

inline

Set the LongitudinalAcceleration object.

AccelerationConfidence is set to UNAVAILABLE

Parameters

accel	object to set
value	LongitudinalAccelerationValue in m/s^2 as decimal number (braking is negative)
confidence	standard deviation of the longitudinal acceleration in m/s^2 as decimal number Default is infinity, mapping to AccelerationConfidence::UNAVAILABLE

Definition at line 146 of file cam_setters.h.

                                                                                           {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,

setLongitudinalAccelerationValue()

void etsi_its_cam_msgs::access::setLongitudinalAccelerationValue ( LongitudinalAccelerationValue & accel, const double value )

inline

Set the LongitudinalAccelerationValue object.

Parameters

accel	object to set
value	LongitudinalAccelerationValue in m/s^2 as decimal number (braking is negative)

Definition at line 125 of file cam_setters.h.

                          {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }

setPosConfidenceEllipse() [1/2]

template<typename PosConfidenceEllipse>

void etsi_its_cam_msgs::access::setPosConfidenceEllipse ( PosConfidenceEllipse & position_confidence_ellipse, const double semi_major_axis, const double semi_minor_axis, const double orientation )

inline

Set the Pos Confidence Ellipse object.

Parameters

[out]	position_confidence_ellipse	The PosConfidenceEllipse to set
[in]	semi_major_axis	length of the semi-major axis in meters
[in]	semi_minor_axis	length of the semi-minor axis in meters
[in]	orientation	of the semi-major axis in degrees, with respect to WGS84

Definition at line 451 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setPosConfidenceEllipse() [2/2]

template<typename PosConfidenceEllipse>

void etsi_its_cam_msgs::access::setPosConfidenceEllipse ( PosConfidenceEllipse & position_confidence_ellipse, const std::array< double, 4 > & covariance_matrix, const double object_heading )

inline

Set the Pos Confidence Ellipse object.

Parameters

position_confidence_ellipse
covariance_matrix	The four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the object (x = longitudinal, y = lateral)
object_heading	The heading of the object in rad, with respect to WGS84

Definition at line 524 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setReferencePosition() [1/2]

void etsi_its_cam_msgs::access::setReferencePosition ( CAM & cam, const double latitude, const double longitude, const double altitude = AltitudeValue::UNAVAILABLE )

inline

Set the ReferencePosition for a CAM.

This function sets the latitude, longitude, and altitude of the CAMs reference position. If the altitude is not provided, it is set to AltitudeValue::UNAVAILABLE.

Parameters

cam	CAM to set the ReferencePosition
latitude	The latitude value position in degree as decimal number.
longitude	The longitude value in degree as decimal number.
altitude	The altitude value (above the reference ellipsoid surface) in meter as decimal number (optional).

Definition at line 246 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setReferencePosition() [2/2]

template<typename T>

void etsi_its_cam_msgs::access::setReferencePosition ( T & ref_position, const double latitude, const double longitude, const double altitude = AltitudeValue::UNAVAILABLE )

inline

Sets the reference position in the given ReferencePostion object.

This function sets the latitude, longitude, and altitude of the reference position. If the altitude is not provided, it is set to AltitudeValue::UNAVAILABLE.

Parameters

ref_position	ReferencePostion or ReferencePositionWithConfidence object to set the reference position in.
latitude	The latitude value position in degree as decimal number.
longitude	The longitude value in degree as decimal number.
altitude	The altitude value (above the reference ellipsoid surface) in meter as decimal number (optional).

Definition at line 288 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setRefPosConfidence()

void etsi_its_cam_msgs::access::setRefPosConfidence ( CAM & cam, const std::array< double, 4 > & covariance_matrix, const double object_heading )

inline

Set the confidence of the reference position.

Parameters

cam	CAM-Message to set the confidence
covariance_matrix	The four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the object (x = longitudinal, y = lateral)
object_heading	heading of the object in rad, with respect to WGS84

Definition at line 363 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setSemiAxis()

template<typename SemiAxisLength>

void etsi_its_cam_msgs::access::setSemiAxis ( SemiAxisLength & semi_axis_length, const double length )

inline

Set the Semi Axis length.

// See https://godbolt.org/z/Eceavfo99 on how the OneCentimeterHelper works with this template

Parameters

semi_axis_length	The SemiAxisLength to set
length	the desired length in meters

Definition at line 432 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setSpecialTransportType()

void etsi_its_cam_msgs::access::setSpecialTransportType ( SpecialTransportType & special_transport_type, const std::vector< bool > & bits )

inline

Set the Special Transport Type by a vector of bools.

Parameters

special_transport_type
bits

Definition at line 328 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setSpeed() [1/2]

void etsi_its_cam_msgs::access::setSpeed ( CAM & cam, const double speed_val, const double confidence = SpeedConfidence::UNAVAILABLE )

inline

Set the vehicle speed.

Parameters

cam	CAM to set the speed value
speed_val	speed value to set in m/s as decimal number

Definition at line 201 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setSpeed() [2/2]

void etsi_its_cam_msgs::access::setSpeed ( Speed & speed, const double value, const double confidence = std::numeric_limits<double>::infinity() )

inline

Set the Speed object.

SpeedConfidence is set to UNAVAILABLE

Parameters

speed	object to set
value	Speed in in m/s as decimal number
confidence	standard deviation in m/s as decimal number (Optional. Default is std::numeric_limits<double>::infinity(), mapping to SpeedConfidence::UNAVAILABLE)

Definition at line 208 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setSpeedConfidence()

void etsi_its_cam_msgs::access::setSpeedConfidence ( SpeedConfidence & speed_confidence, const double value )

inline

Set the Speed Confidence object.

Parameters

speed_confidence	object to set
value	standard deviation in m/s as decimal number

Definition at line 189 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setSpeedValue()

void etsi_its_cam_msgs::access::setSpeedValue ( SpeedValue & speed, const double value )

inline

Set the SpeedValue object.

Parameters

speed	object to set
value	SpeedValue in m/s as decimal number

Definition at line 177 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setStationId()

void etsi_its_cam_msgs::access::setStationId ( StationID & station_id, const uint32_t id_value )

inline

Set the Station Id object.

Parameters

station_id
id_value

Definition at line 72 of file cam_setters.h.

setStationType() [1/2]

void etsi_its_cam_msgs::access::setStationType ( CAM & cam, const uint8_t value )

inline

Set the StationType for a CAM.

Parameters

cam	CAM-Message to set the station_type value
value	station_type value to set

Definition at line 110 of file cam_setters.h.

setStationType() [2/2]

void etsi_its_cam_msgs::access::setStationType ( StationType & station_type, const uint8_t value )

inline

Set the Station Type.

Parameters

station_type
value

Definition at line 101 of file cam_setters.h.

setTimestampITS()

void etsi_its_cam_msgs::access::setTimestampITS ( TimestampIts & timestamp_its, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.rbegin()->second )

inline

Set the TimestampITS object.

Parameters

[in]	timestamp_its	TimestampITS object to set the timestamp
[in]	unix_nanosecs	Unix-Nanoseconds to set the timestamp for
[in]	n_leap_seconds	Number of leap-seconds since 2004. (Defaults to the todays number of leap seconds since 2004.)
[in]	epoch_offset	Unix-Timestamp in seconds for the 01.01.2004 at 00:00:00

Definition at line 109 of file cam_setters.h.

setVehicleDimensions()

void etsi_its_cam_msgs::access::setVehicleDimensions ( CAM & cam, const double vehicle_length, const double vehicle_width )

inline

Set the vehicle dimensions.

Parameters

cam	CAM to set the vehicle dimensions
vehicle_length	vehicle length in meter as decimal number
vehicle_width	vehicle width in meter as decimal number

Definition at line 187 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setVehicleLength()

void etsi_its_cam_msgs::access::setVehicleLength ( VehicleLength & vehicle_length, const double value )

inline

Set the VehicleLength object.

VehicleLengthConfidenceIndication is set to UNAVAILABLE

Parameters

vehicle_length	object to set
value	VehicleLengthValue in meter as decimal number

Definition at line 175 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setVehicleLengthValue()

void etsi_its_cam_msgs::access::setVehicleLengthValue ( VehicleLengthValue & vehicle_length, const double value )

inline

Set the VehicleLengthValue object.

Parameters

vehicle_length	object to set
value	VehicleLengthValue in meter as decimal number

Definition at line 161 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setVehicleWidth()

void etsi_its_cam_msgs::access::setVehicleWidth ( VehicleWidth & vehicle_width, const double value )

inline

Set the VehicleWidth object.

Parameters

vehicle_width	object to set
value	VehicleWidth in meter as decimal number

Definition at line 149 of file cam_setters.h.

setWGSPosConfidenceEllipse()

template<typename PosConfidenceEllipse>

void etsi_its_cam_msgs::access::setWGSPosConfidenceEllipse ( PosConfidenceEllipse & position_confidence_ellipse, const std::array< double, 4 > & covariance_matrix )

inline

Set the Pos Confidence Ellipse object.

Parameters

position_confidence_ellipse
covariance_matrix	The four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is aligned with the WGS axes (x = North, y = East)
object_heading	The heading of the object in rad, with respect to WGS84

Definition at line 539 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setWGSRefPosConfidence()

void etsi_its_cam_msgs::access::setWGSRefPosConfidence ( CAM & cam, const std::array< double, 4 > & covariance_matrix )

inline

Set the confidence of the reference position.

Parameters

cam	CAM-Message to set the confidence
covariance_matrix	The four values of the covariance matrix in the order: cov_xx, cov_xy, cov_yx, cov_yy The matrix has to be SPD, otherwise a std::invalid_argument exception is thrown. Its coordinate system is WGS84 (x = North, y = East)

Definition at line 387 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

setYawRate()

void etsi_its_cam_msgs::access::setYawRate ( CAM & cam, const double yaw_rate_val, const double confidence = std::numeric_limits<double>::infinity() )

inline

Set the Yaw Rate for a CAM.

Parameters

cam	CAM to set the YawRate
yaw_rate_val	Yaw rate value in degrees per second as decimal number
confidence	standard deviation of yaw rate in degrees per second as decimal number (default: infinity, mapping to YawRateConfidence::UNAVAILABLE)

Definition at line 137 of file cam_setters.h.

setYawRateCDD()

template<typename YawRate, typename YawRateValue = decltype(YawRate::yaw_rate_value), typename YawRateConfidence = decltype(YawRate::yaw_rate_confidence)>

void etsi_its_cam_msgs::access::setYawRateCDD ( YawRate & yaw_rate, const double value, double confidence = std::numeric_limits<double>::infinity() )

inline

Set the Yaw Rate object.

Parameters

yaw_rate	object to set
value	Yaw rate in degrees per second as decimal number
confidence	standard deviation of yaw rate in degrees per second as decimal number (default: infinity, mapping to YawRateConfidence::UNAVAILABLE)

Definition at line 386 of file cam_setters.h.

                                  {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v1-3-1_setters.h>

inline void setItsPduHeader(CAM &cam, const uint32_t station_id, const uint8_t protocol_version = 0) {
  setItsPduHeader(cam.header, ItsPduHeader::MESSAGE_ID_CAM, station_id, protocol_version);
}

inline void setLongitudinalAccelerationValue(LongitudinalAccelerationValue& accel, const double value) {
  auto accel_val = std::round(value * 1e1);
  if (accel_val >= LongitudinalAccelerationValue::MIN && accel_val <= LongitudinalAccelerationValue::MAX) {
    accel.value = static_cast<int16_t>(accel_val);
  } else if (accel_val < LongitudinalAccelerationValue::MIN) {
    accel.value = LongitudinalAccelerationValue::MIN;
  } else if (accel_val > LongitudinalAccelerationValue::MAX) {
    accel.value = LongitudinalAccelerationValue::MAX - 1;
  }
}

inline void setLongitudinalAcceleration(LongitudinalAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.longitudinal_acceleration_confidence, confidence);
  setLongitudinalAccelerationValue(accel.longitudinal_acceleration_value, value);
}

inline void setLateralAccelerationValue(LateralAccelerationValue& accel, const double value) {
  int64_t accel_val = (int64_t)std::round(value * 1e1);
  if (accel_val >= LateralAccelerationValue::MIN && accel_val <= LateralAccelerationValue::MAX) {
    accel.value = accel_val;
  } else if (accel_val < LateralAccelerationValue::MIN) {
    accel.value = LateralAccelerationValue::MIN;
  } else if (accel_val > LateralAccelerationValue::MAX) {
    accel.value = LateralAccelerationValue::MAX - 1;
  }
}

inline void setLateralAcceleration(LateralAcceleration& accel, const double value, const double confidence = std::numeric_limits<double>::infinity()) {
  setAccelerationConfidence(accel.lateral_acceleration_confidence, confidence);
  setLateralAccelerationValue(accel.lateral_acceleration_value, value);
}
 
#include <etsi_its_msgs_utils/impl/cam/cam_setters_common.h>

inline void setRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix, const double object_heading) {
  // First ensure, that the object has the correct heading by setting its value
  double orientation = object_heading * 180 / M_PI; // Convert to degrees
  // Normalize to [0, 360)
  orientation = std::fmod(orientation + 360, 360);
  while (orientation < 0) {
    orientation += 360;
  }
  while (orientation >= 360) {
    orientation -= 360;
  }
  setHeading(cam, orientation);
  setPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                          covariance_matrix, object_heading);
}

inline void setWGSRefPosConfidence(CAM& cam, const std::array<double, 4>& covariance_matrix) {
  setWGSPosConfidenceEllipse(cam.cam.cam_parameters.basic_container.reference_position.position_confidence_ellipse,
                             covariance_matrix);
}
 
}  // namespace etsi_its_cam_msgs::access

throwIfNotPresent()

void etsi_its_cam_msgs::access::throwIfNotPresent ( const bool is_present, const std::string val_desc )

inline

Throws an exception if the given value is not present.

Parameters

is_present	Whether the value is present.
val_desc	Description of the value for the exception message.

Definition at line 58 of file cam_access.h.

throwIfOutOfRange()

template<typename T1, typename T2>

void etsi_its_cam_msgs::access::throwIfOutOfRange	(	const T1 &	val,
		const T2 &	min,
		const T2 &	max,
		const std::string	val_desc )

Throws an exception if a given value is out of a defined range.

Template Parameters

T1
T2

Parameters

val	The value to check if it is in the range.
min	The minimum value of the range.
max	The maximum value of the range.
val_desc	Description of the value for the exception message.

Definition at line 47 of file cam_access.h.