cpm_ts_setters.h File Reference

Setter functions for the ETSI ITS CPM (TS) More...

#include <etsi_its_msgs_utils/impl/constants.h>
#include <etsi_its_msgs_utils/impl/cdd/cdd_v2-1-1_setters.h>

Go to the source code of this file.

Functions
template<typename T1 , typename T2 >
void	etsi_its_cpm_ts_msgs::access::throwIfOutOfRange (const T1 &val, const T2 &min, const T2 &max, const std::string val_desc)
uint16_t	etsi_its_cpm_ts_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_cpm_ts_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.end() ->second)
	Set the TimestampITS object.
void	etsi_its_cpm_ts_msgs::access::setLatitude (Latitude &latitude, const double deg)
	Set the Latitude object.
void	etsi_its_cpm_ts_msgs::access::setLongitude (Longitude &longitude, const double deg)
	Set the Longitude object.
void	etsi_its_cpm_ts_msgs::access::setAltitudeValue (AltitudeValue &altitude, const double value)
	Set the AltitudeValue object.
void	etsi_its_cpm_ts_msgs::access::setAltitude (Altitude &altitude, const double value)
	Set the Altitude object.
void	etsi_its_cpm_ts_msgs::access::setSpeedValue (SpeedValue &speed, const double value)
	Set the SpeedValue object.
void	etsi_its_cpm_ts_msgs::access::setSpeed (Speed &speed, const double value)
	Set the Speed object.
template<typename T >
void	etsi_its_cpm_ts_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_cpm_ts_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 T >
void	etsi_its_cpm_ts_msgs::access::setBitString (T &bitstring, const std::vector< bool > &bits)
	Set a Bit String by a vector of bools.
void	etsi_its_cpm_ts_msgs::access::setStationId (StationId &station_id, const uint32_t id_value)
	Set the Station Id object.
void	etsi_its_cpm_ts_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_cpm_ts_msgs::access::setStationType (TrafficParticipantType &station_type, const uint8_t value)
	Set the Station Type.
void	etsi_its_cpm_ts_msgs::access::setLongitudinalAccelerationValue (AccelerationValue &accel, const double value)
	Set the LongitudinalAccelerationValue object.
void	etsi_its_cpm_ts_msgs::access::setLongitudinalAcceleration (AccelerationComponent &accel, const double value)
	Set the LongitudinalAcceleration object.
void	etsi_its_cpm_ts_msgs::access::setLateralAccelerationValue (AccelerationValue &accel, const double value)
	Set the LateralAccelerationValue object.
void	etsi_its_cpm_ts_msgs::access::setLateralAcceleration (AccelerationComponent &accel, const double value)
	Set the LateralAcceleration object.
void	etsi_its_cpm_ts_msgs::access::setItsPduHeader (CollectivePerceptionMessage &cpm, const uint32_t station_id, const uint8_t protocol_version=0)
	Sets the ITS PDU header of a CPM.
void	etsi_its_cpm_ts_msgs::access::setReferenceTime (CollectivePerceptionMessage &cpm, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds=etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.end() ->second)
	Sets the reference time in a CPM.
void	etsi_its_cpm_ts_msgs::access::setReferencePosition (CollectivePerceptionMessage &cpm, const double latitude, const double longitude, const double altitude=AltitudeValue::UNAVAILABLE)
	Set the ReferencePositionWithConfidence for a CPM TS.
void	etsi_its_cpm_ts_msgs::access::setFromUTMPosition (CollectivePerceptionMessage &cpm, const gm::PointStamped &utm_position, const int &zone, const bool &northp)
	Set the ReferencePosition of a CPM from a given UTM-Position.
void	etsi_its_cpm_ts_msgs::access::setIdOfPerceivedObject (PerceivedObject &object, const uint16_t id)
	Set the ID of a PerceivedObject.
void	etsi_its_cpm_ts_msgs::access::setMeasurementDeltaTimeOfPerceivedObject (PerceivedObject &object, const int16_t delta_time=0)
	Sets the measurement delta time of a PerceivedObject.
void	etsi_its_cpm_ts_msgs::access::setCartesianCoordinateWithConfidence (CartesianCoordinateWithConfidence &coordinate, const int32_t value, const uint16_t confidence=CoordinateConfidence::UNAVAILABLE)
	Sets the value and confidence of a CartesianCoordinateWithConfidence object.
void	etsi_its_cpm_ts_msgs::access::setPositionOfPerceivedObject (PerceivedObject &object, const gm::Point &point, const uint16_t x_confidence=CoordinateConfidence::UNAVAILABLE, const uint16_t y_confidence=CoordinateConfidence::UNAVAILABLE, const uint16_t z_confidence=CoordinateConfidence::UNAVAILABLE)
	Sets the position of a perceived object (relative to the CPM's reference position).
void	etsi_its_cpm_ts_msgs::access::setUTMPositionOfPerceivedObject (CollectivePerceptionMessage &cpm, PerceivedObject &object, const gm::PointStamped &utm_position, const uint16_t x_confidence=CoordinateConfidence::UNAVAILABLE, const uint16_t y_confidence=CoordinateConfidence::UNAVAILABLE, const uint16_t z_confidence=CoordinateConfidence::UNAVAILABLE)
	Sets the position of a perceived object based on a UTM position.
void	etsi_its_cpm_ts_msgs::access::setVelocityComponent (VelocityComponent &velocity, const int16_t value, const uint8_t confidence=SpeedConfidence::UNAVAILABLE)
	Sets the value and confidence of a VelocityComponent.
void	etsi_its_cpm_ts_msgs::access::setVelocityOfPerceivedObject (PerceivedObject &object, const gm::Vector3 &cartesian_velocity, const uint8_t x_confidence=SpeedConfidence::UNAVAILABLE, const uint8_t y_confidence=SpeedConfidence::UNAVAILABLE, const uint8_t z_confidence=SpeedConfidence::UNAVAILABLE)
void	etsi_its_cpm_ts_msgs::access::setAccelerationComponent (AccelerationComponent &acceleration, const int16_t value, const uint8_t confidence=AccelerationConfidence::UNAVAILABLE)
	Sets the value and confidence of a AccelerationComponent.
void	etsi_its_cpm_ts_msgs::access::setAccelerationOfPerceivedObject (PerceivedObject &object, const gm::Vector3 &cartesian_acceleration, const uint8_t x_confidence=AccelerationConfidence::UNAVAILABLE, const uint8_t y_confidence=AccelerationConfidence::UNAVAILABLE, const uint8_t z_confidence=AccelerationConfidence::UNAVAILABLE)
	Sets the acceleration of a perceived object.
void	etsi_its_cpm_ts_msgs::access::setYawOfPerceivedObject (PerceivedObject &object, const double yaw, const uint8_t confidence=AngleConfidence::UNAVAILABLE)
	Sets the yaw angle of a perceived object.
void	etsi_its_cpm_ts_msgs::access::setYawRateOfPerceivedObject (PerceivedObject &object, const double yaw_rate, const uint8_t confidence=AngularSpeedConfidence::UNAVAILABLE)
	Sets the yaw rate of a perceived object.
void	etsi_its_cpm_ts_msgs::access::setObjectDimension (ObjectDimension &dimension, const uint16_t value, const uint8_t confidence=ObjectDimensionConfidence::UNAVAILABLE)
	Sets the object dimension with the given value and confidence.
void	etsi_its_cpm_ts_msgs::access::setXDimensionOfPerceivedObject (PerceivedObject &object, const double value, const uint8_t confidence=ObjectDimensionConfidence::UNAVAILABLE)
	Sets the x-dimension of a perceived object.
void	etsi_its_cpm_ts_msgs::access::setYDimensionOfPerceivedObject (PerceivedObject &object, const double value, const uint8_t confidence=ObjectDimensionConfidence::UNAVAILABLE)
	Sets the y-dimension of a perceived object.
void	etsi_its_cpm_ts_msgs::access::setZDimensionOfPerceivedObject (PerceivedObject &object, const double value, const uint8_t confidence=ObjectDimensionConfidence::UNAVAILABLE)
	Sets the z-dimension of a perceived object.
void	etsi_its_cpm_ts_msgs::access::setDimensionsOfPerceivedObject (PerceivedObject &object, const gm::Vector3 &dimensions, const uint8_t x_confidence=ObjectDimensionConfidence::UNAVAILABLE, const uint8_t y_confidence=ObjectDimensionConfidence::UNAVAILABLE, const uint8_t z_confidence=ObjectDimensionConfidence::UNAVAILABLE)
	Sets all dimensions of a perceived object.
void	etsi_its_cpm_ts_msgs::access::initPerceivedObject (PerceivedObject &object, const gm::Point &point, const int16_t delta_time=0)
	Initializes a PerceivedObject with the given point and delta time.
void	etsi_its_cpm_ts_msgs::access::initPerceivedObjectWithUTMPosition (CollectivePerceptionMessage &cpm, PerceivedObject &object, const gm::PointStamped &point, const int16_t delta_time=0)
	Initializes a PerceivedObject with the given point (utm-position) and delta time.
void	etsi_its_cpm_ts_msgs::access::initPerceivedObjectContainer (WrappedCpmContainer &container, const uint8_t n_objects=0)
	Initializes a WrappedCpmContainer as a PerceivedObjectContainer with the given number of objects.
void	etsi_its_cpm_ts_msgs::access::addPerceivedObjectToContainer (WrappedCpmContainer &container, const PerceivedObject &perceived_object)
	Adds a PerceivedObject to the PerceivedObjectContainer / WrappedCpmContainer.
void	etsi_its_cpm_ts_msgs::access::addContainerToCPM (CollectivePerceptionMessage &cpm, const WrappedCpmContainer &container)
	Adds a container to the Collective Perception Message (CPM).

Detailed Description

Setter functions for the ETSI ITS CPM (TS)

Definition in file cpm_ts_setters.h.

Function Documentation

addContainerToCPM()

void etsi_its_cpm_ts_msgs::access::addContainerToCPM ( CollectivePerceptionMessage & cpm, const WrappedCpmContainer & container )

inline

Adds a container to the Collective Perception Message (CPM).

This function adds a WrappedCpmContainer to the CPM's payload. It first checks if the current number of containers is less than the maximum allowed. If so, it appends the container to the array. Otherwise, it throws an exception.

Parameters

cpm	The Collective Perception Message to which the container will be added.
container	The WrappedCpmContainer to be added to the CPM.

Exceptions

std::invalid_argument

if the maximum number of CPM-Containers is reached.

Definition at line 717 of file cpm_ts_setters.h.

addPerceivedObjectToContainer()

void etsi_its_cpm_ts_msgs::access::addPerceivedObjectToContainer ( WrappedCpmContainer & container, const PerceivedObject & perceived_object )

inline

Adds a PerceivedObject to the PerceivedObjectContainer / WrappedCpmContainer.

This function checks if the provided container is a PerceivedObjectContainer. If it is, the function adds the given PerceivedObject to the container's perceived_objects array and updates the number_of_perceived_objects value. If the container is not a PerceivedObjectContainer, the function throws an std::invalid_argument exception.

Parameters

container	The WrappedCpmContainer to which the PerceivedObject will be added.
perceived_object	The PerceivedObject to add to the container.

Exceptions

std::invalid_argument

if the container is not a PerceivedObjectContainer.

Definition at line 694 of file cpm_ts_setters.h.

                                     {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v2-1-1_setters.h>
 
inline void setItsPduHeader(CollectivePerceptionMessage& cpm, const uint32_t station_id,
                            const uint8_t protocol_version = 0) {
  setItsPduHeader(cpm.header, MessageId::CPM, station_id, protocol_version);
}
 
inline void setReferenceTime(
    CollectivePerceptionMessage& cpm, const uint64_t unix_nanosecs,
    const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.end()->second) {
  TimestampIts t_its;
  setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
  throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
  cpm.payload.management_container.reference_time = t_its;
}
 
inline void setReferencePosition(CollectivePerceptionMessage& cpm, const double latitude, const double longitude,
                                 const double altitude = AltitudeValue::UNAVAILABLE) {
  setReferencePosition(cpm.payload.management_container.reference_position, latitude, longitude, altitude);
}
 
inline void setFromUTMPosition(CollectivePerceptionMessage& cpm, const gm::PointStamped& utm_position, const int& zone,
                               const bool& northp) {
  setFromUTMPosition(cpm.payload.management_container.reference_position, utm_position, zone, northp);
}
 
inline void setIdOfPerceivedObject(PerceivedObject& object, const uint16_t id) {
  object.object_id.value = id;
  object.object_id_is_present = true;
}
 
inline void setMeasurementDeltaTimeOfPerceivedObject(PerceivedObject& object, const int16_t delta_time = 0) {
  if (delta_time < DeltaTimeMilliSecondSigned::MIN || delta_time > DeltaTimeMilliSecondSigned::MAX) {
    throw std::invalid_argument("MeasurementDeltaTime out of range");
  } else {
    object.measurement_delta_time.value = delta_time;
  }
}
 
inline void setCartesianCoordinateWithConfidence(CartesianCoordinateWithConfidence& coordinate, const int32_t value,
                                                 const uint16_t confidence = CoordinateConfidence::UNAVAILABLE) {
  // limit value range
  if (value < CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE;
  } else if (value > CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE;
  } else {
    coordinate.value.value = value;
  }
 
  // limit confidence range
  if (confidence > CoordinateConfidence::MAX || confidence < CoordinateConfidence::MIN) {
    coordinate.confidence.value = CoordinateConfidence::OUT_OF_RANGE;
  } else {
    coordinate.confidence.value = confidence;
  }
}
 
inline void setPositionOfPerceivedObject(PerceivedObject& object, const gm::Point& point,
                                         const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  setCartesianCoordinateWithConfidence(object.position.x_coordinate, point.x * 100, x_confidence * 100);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate, point.y * 100, y_confidence * 100);
  if (point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate, point.z * 100, z_confidence * 100);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setUTMPositionOfPerceivedObject(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                            const gm::PointStamped& utm_position,
                                            const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  gm::PointStamped reference_position = getUTMPosition(cpm);
  if (utm_position.header.frame_id != reference_position.header.frame_id) {
    throw std::invalid_argument("UTM-Position frame_id (" + utm_position.header.frame_id +
                                ") does not match the reference position frame_id (" + reference_position.header.frame_id +
                                ")");
  }
  setCartesianCoordinateWithConfidence(object.position.x_coordinate,
                                       (utm_position.point.x - reference_position.point.x) * 100, x_confidence);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate,
                                       (utm_position.point.y - reference_position.point.y) * 100, y_confidence);
  if (utm_position.point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate,
                                         (utm_position.point.z - reference_position.point.z) * 100, z_confidence);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setVelocityComponent(VelocityComponent& velocity, const int16_t value,
                                 const uint8_t confidence = SpeedConfidence::UNAVAILABLE) {
  // limit value range
  if (value < VelocityComponentValue::NEGATIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > VelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::POSITIVE_OUT_OF_RANGE;
  } else {
    velocity.value.value = value;
  }
 
  // limit confidence range
  if (confidence > SpeedConfidence::MAX || confidence < SpeedConfidence::MIN) {
    velocity.confidence.value = SpeedConfidence::OUT_OF_RANGE;
  } else {
    velocity.confidence.value = confidence;
  }
}
 
inline void setVelocityOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_velocity,
                                         const uint8_t x_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t y_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t z_confidence = SpeedConfidence::UNAVAILABLE) {
  object.velocity.choice = Velocity3dWithConfidence::CHOICE_CARTESIAN_VELOCITY;
  setVelocityComponent(object.velocity.cartesian_velocity.x_velocity, cartesian_velocity.x * 100, x_confidence * 100);
  setVelocityComponent(object.velocity.cartesian_velocity.y_velocity, cartesian_velocity.y * 100, y_confidence * 100);
  if (cartesian_velocity.z != 0.0) {
    setVelocityComponent(object.velocity.cartesian_velocity.z_velocity, cartesian_velocity.z * 100, z_confidence * 100);
    object.velocity.cartesian_velocity.z_velocity_is_present = true;
  }
  object.velocity_is_present = true;
}
 
inline void setAccelerationComponent(AccelerationComponent& acceleration, const int16_t value,
                                     const uint8_t confidence = AccelerationConfidence::UNAVAILABLE) {
  // limit value range
  if (value < AccelerationValue::NEGATIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > AccelerationValue::POSITIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::POSITIVE_OUT_OF_RANGE;
  } else {
    acceleration.value.value = value;
  }
 
  // limit confidence range
  if (confidence > AccelerationConfidence::MAX || confidence < AccelerationConfidence::MIN) {
    acceleration.confidence.value = AccelerationConfidence::OUT_OF_RANGE;
  } else {
    acceleration.confidence.value = confidence;
  }
}
 
inline void setAccelerationOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_acceleration,
                                             const uint8_t x_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t y_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t z_confidence = AccelerationConfidence::UNAVAILABLE) {
  object.acceleration.choice = Acceleration3dWithConfidence::CHOICE_CARTESIAN_ACCELERATION;
  setAccelerationComponent(object.acceleration.cartesian_acceleration.x_acceleration, cartesian_acceleration.x * 10,
                           x_confidence * 10);
  setAccelerationComponent(object.acceleration.cartesian_acceleration.y_acceleration, cartesian_acceleration.y * 10,
                           y_confidence * 10);
  if (cartesian_acceleration.z != 0.0) {
    setAccelerationComponent(object.acceleration.cartesian_acceleration.z_acceleration, cartesian_acceleration.z * 10,
                             z_confidence * 10);
    object.acceleration.cartesian_acceleration.z_acceleration_is_present = true;
  }
  object.acceleration_is_present = true;
}
 
inline void setYawOfPerceivedObject(PerceivedObject& object, const double yaw,
                                    const uint8_t confidence = AngleConfidence::UNAVAILABLE) {
  // wrap angle to range [0, 360]
  double yaw_in_degrees = yaw * 180 / M_PI + 180;  // TODO: check if this is correct
  while (yaw_in_degrees > 360.0) yaw_in_degrees -= 360.0;
  while (yaw_in_degrees < 0) yaw_in_degrees += 360.0;
  object.angles.z_angle.value.value = yaw_in_degrees * 10;
 
  if (confidence > AngleConfidence::MAX || confidence < AngleConfidence::MIN) {
    object.angles.z_angle.confidence.value = AngleConfidence::OUT_OF_RANGE;
  } else {
    object.angles.z_angle.confidence.value = confidence;
  }
  object.angles_is_present = true;
}
 
inline void setYawRateOfPerceivedObject(PerceivedObject& object, const double yaw_rate,
                                        const uint8_t confidence = AngularSpeedConfidence::UNAVAILABLE) {
  int16_t yaw_rate_in_degrees = yaw_rate * 180 / M_PI;
  if (yaw_rate_in_degrees != CartesianAngularVelocityComponentValue::UNAVAILABLE) {
    // limit value range
    if (yaw_rate_in_degrees < CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE;
    } else if (yaw_rate_in_degrees > CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE;
    }
  }
  object.z_angular_velocity.value.value = yaw_rate_in_degrees;
  object.z_angular_velocity.confidence.value = confidence;
  object.z_angular_velocity_is_present = true;
}
 
inline void setObjectDimension(ObjectDimension& dimension, const uint16_t value,
                               const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  // limit value range
  if (value < ObjectDimensionValue::MIN || value > ObjectDimensionValue::MAX) {
    dimension.value.value = ObjectDimensionValue::OUT_OF_RANGE;
  } else {
    dimension.value.value = value;
  }
 
  // limit confidence range
  if (confidence > ObjectDimensionConfidence::MAX || confidence < ObjectDimensionConfidence::MIN) {
    dimension.confidence.value = ObjectDimensionConfidence::OUT_OF_RANGE;
  } else {
    dimension.confidence.value = confidence;
  }
}
 
inline void setXDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_x, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_x_is_present = true;
}
 
inline void setYDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_y, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_y_is_present = true;
}
 
inline void setZDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_z, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_z_is_present = true;
}
 
inline void setDimensionsOfPerceivedObject(PerceivedObject& object, const gm::Vector3& dimensions,
                                           const uint8_t x_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t y_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t z_confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setXDimensionOfPerceivedObject(object, dimensions.x, x_confidence);
  setYDimensionOfPerceivedObject(object, dimensions.y, y_confidence);
  setZDimensionOfPerceivedObject(object, dimensions.z, z_confidence);
}
 
inline void initPerceivedObject(PerceivedObject& object, const gm::Point& point, const int16_t delta_time = 0) {
  setPositionOfPerceivedObject(object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectWithUTMPosition(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                               const gm::PointStamped& point, const int16_t delta_time = 0) {
  setUTMPositionOfPerceivedObject(cpm, object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectContainer(WrappedCpmContainer& container, const uint8_t n_objects = 0) {
  container.container_id.value = CpmContainerId::PERCEIVED_OBJECT_CONTAINER;
  container.container_data.choice = container.container_id;
  container.container_data.perceived_object_container.number_of_perceived_objects.value = n_objects;
}
 
inline void addPerceivedObjectToContainer(WrappedCpmContainer& container, const PerceivedObject& perceived_object) {
  if (container.container_id.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER &&
      container.container_data.choice.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER) {
    container.container_data.perceived_object_container.perceived_objects.array.push_back(perceived_object);
    container.container_data.perceived_object_container.number_of_perceived_objects.value =
        container.container_data.perceived_object_container.perceived_objects.array.size();
  } else {
    throw std::invalid_argument("Container is not a PerceivedObjectContainer");
  }
}
 
inline void addContainerToCPM(CollectivePerceptionMessage& cpm, const WrappedCpmContainer& container) {
  // check for maximum number of containers
  if (cpm.payload.cpm_containers.value.array.size() < WrappedCpmContainers::MAX_SIZE) {
    cpm.payload.cpm_containers.value.array.push_back(container);
  } else {
    throw std::invalid_argument("Maximum number of CPM-Containers reached");
  }
}
 
}  // namespace etsi_its_cpm_ts_msgs::access

getLeapSecondInsertionsSince2004()

uint16_t etsi_its_cpm_ts_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 cpm_ts_access.h.

initPerceivedObject()

void etsi_its_cpm_ts_msgs::access::initPerceivedObject ( PerceivedObject & object, const gm::Point & point, const int16_t delta_time = 0 )

inline

Initializes a PerceivedObject with the given point and delta time.

This function sets the position and measurement delta time of the PerceivedObject.

Parameters

object	The PerceivedObject to be initialized.
point	The position of the PerceivedObject relative to the CPM's reference position in meters.
delta_time	The measurement delta time of the PerceivedObject in milliseconds (default = 0).

Definition at line 643 of file cpm_ts_setters.h.

                                     {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v2-1-1_setters.h>
 
inline void setItsPduHeader(CollectivePerceptionMessage& cpm, const uint32_t station_id,
                            const uint8_t protocol_version = 0) {
  setItsPduHeader(cpm.header, MessageId::CPM, station_id, protocol_version);
}
 
inline void setReferenceTime(
    CollectivePerceptionMessage& cpm, const uint64_t unix_nanosecs,
    const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.end()->second) {
  TimestampIts t_its;
  setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
  throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
  cpm.payload.management_container.reference_time = t_its;
}
 
inline void setReferencePosition(CollectivePerceptionMessage& cpm, const double latitude, const double longitude,
                                 const double altitude = AltitudeValue::UNAVAILABLE) {
  setReferencePosition(cpm.payload.management_container.reference_position, latitude, longitude, altitude);
}
 
inline void setFromUTMPosition(CollectivePerceptionMessage& cpm, const gm::PointStamped& utm_position, const int& zone,
                               const bool& northp) {
  setFromUTMPosition(cpm.payload.management_container.reference_position, utm_position, zone, northp);
}
 
inline void setIdOfPerceivedObject(PerceivedObject& object, const uint16_t id) {
  object.object_id.value = id;
  object.object_id_is_present = true;
}
 
inline void setMeasurementDeltaTimeOfPerceivedObject(PerceivedObject& object, const int16_t delta_time = 0) {
  if (delta_time < DeltaTimeMilliSecondSigned::MIN || delta_time > DeltaTimeMilliSecondSigned::MAX) {
    throw std::invalid_argument("MeasurementDeltaTime out of range");
  } else {
    object.measurement_delta_time.value = delta_time;
  }
}
 
inline void setCartesianCoordinateWithConfidence(CartesianCoordinateWithConfidence& coordinate, const int32_t value,
                                                 const uint16_t confidence = CoordinateConfidence::UNAVAILABLE) {
  // limit value range
  if (value < CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE;
  } else if (value > CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE;
  } else {
    coordinate.value.value = value;
  }
 
  // limit confidence range
  if (confidence > CoordinateConfidence::MAX || confidence < CoordinateConfidence::MIN) {
    coordinate.confidence.value = CoordinateConfidence::OUT_OF_RANGE;
  } else {
    coordinate.confidence.value = confidence;
  }
}
 
inline void setPositionOfPerceivedObject(PerceivedObject& object, const gm::Point& point,
                                         const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  setCartesianCoordinateWithConfidence(object.position.x_coordinate, point.x * 100, x_confidence * 100);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate, point.y * 100, y_confidence * 100);
  if (point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate, point.z * 100, z_confidence * 100);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setUTMPositionOfPerceivedObject(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                            const gm::PointStamped& utm_position,
                                            const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  gm::PointStamped reference_position = getUTMPosition(cpm);
  if (utm_position.header.frame_id != reference_position.header.frame_id) {
    throw std::invalid_argument("UTM-Position frame_id (" + utm_position.header.frame_id +
                                ") does not match the reference position frame_id (" + reference_position.header.frame_id +
                                ")");
  }
  setCartesianCoordinateWithConfidence(object.position.x_coordinate,
                                       (utm_position.point.x - reference_position.point.x) * 100, x_confidence);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate,
                                       (utm_position.point.y - reference_position.point.y) * 100, y_confidence);
  if (utm_position.point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate,
                                         (utm_position.point.z - reference_position.point.z) * 100, z_confidence);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setVelocityComponent(VelocityComponent& velocity, const int16_t value,
                                 const uint8_t confidence = SpeedConfidence::UNAVAILABLE) {
  // limit value range
  if (value < VelocityComponentValue::NEGATIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > VelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::POSITIVE_OUT_OF_RANGE;
  } else {
    velocity.value.value = value;
  }
 
  // limit confidence range
  if (confidence > SpeedConfidence::MAX || confidence < SpeedConfidence::MIN) {
    velocity.confidence.value = SpeedConfidence::OUT_OF_RANGE;
  } else {
    velocity.confidence.value = confidence;
  }
}
 
inline void setVelocityOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_velocity,
                                         const uint8_t x_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t y_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t z_confidence = SpeedConfidence::UNAVAILABLE) {
  object.velocity.choice = Velocity3dWithConfidence::CHOICE_CARTESIAN_VELOCITY;
  setVelocityComponent(object.velocity.cartesian_velocity.x_velocity, cartesian_velocity.x * 100, x_confidence * 100);
  setVelocityComponent(object.velocity.cartesian_velocity.y_velocity, cartesian_velocity.y * 100, y_confidence * 100);
  if (cartesian_velocity.z != 0.0) {
    setVelocityComponent(object.velocity.cartesian_velocity.z_velocity, cartesian_velocity.z * 100, z_confidence * 100);
    object.velocity.cartesian_velocity.z_velocity_is_present = true;
  }
  object.velocity_is_present = true;
}
 
inline void setAccelerationComponent(AccelerationComponent& acceleration, const int16_t value,
                                     const uint8_t confidence = AccelerationConfidence::UNAVAILABLE) {
  // limit value range
  if (value < AccelerationValue::NEGATIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > AccelerationValue::POSITIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::POSITIVE_OUT_OF_RANGE;
  } else {
    acceleration.value.value = value;
  }
 
  // limit confidence range
  if (confidence > AccelerationConfidence::MAX || confidence < AccelerationConfidence::MIN) {
    acceleration.confidence.value = AccelerationConfidence::OUT_OF_RANGE;
  } else {
    acceleration.confidence.value = confidence;
  }
}
 
inline void setAccelerationOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_acceleration,
                                             const uint8_t x_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t y_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t z_confidence = AccelerationConfidence::UNAVAILABLE) {
  object.acceleration.choice = Acceleration3dWithConfidence::CHOICE_CARTESIAN_ACCELERATION;
  setAccelerationComponent(object.acceleration.cartesian_acceleration.x_acceleration, cartesian_acceleration.x * 10,
                           x_confidence * 10);
  setAccelerationComponent(object.acceleration.cartesian_acceleration.y_acceleration, cartesian_acceleration.y * 10,
                           y_confidence * 10);
  if (cartesian_acceleration.z != 0.0) {
    setAccelerationComponent(object.acceleration.cartesian_acceleration.z_acceleration, cartesian_acceleration.z * 10,
                             z_confidence * 10);
    object.acceleration.cartesian_acceleration.z_acceleration_is_present = true;
  }
  object.acceleration_is_present = true;
}
 
inline void setYawOfPerceivedObject(PerceivedObject& object, const double yaw,
                                    const uint8_t confidence = AngleConfidence::UNAVAILABLE) {
  // wrap angle to range [0, 360]
  double yaw_in_degrees = yaw * 180 / M_PI + 180;  // TODO: check if this is correct
  while (yaw_in_degrees > 360.0) yaw_in_degrees -= 360.0;
  while (yaw_in_degrees < 0) yaw_in_degrees += 360.0;
  object.angles.z_angle.value.value = yaw_in_degrees * 10;
 
  if (confidence > AngleConfidence::MAX || confidence < AngleConfidence::MIN) {
    object.angles.z_angle.confidence.value = AngleConfidence::OUT_OF_RANGE;
  } else {
    object.angles.z_angle.confidence.value = confidence;
  }
  object.angles_is_present = true;
}
 
inline void setYawRateOfPerceivedObject(PerceivedObject& object, const double yaw_rate,
                                        const uint8_t confidence = AngularSpeedConfidence::UNAVAILABLE) {
  int16_t yaw_rate_in_degrees = yaw_rate * 180 / M_PI;
  if (yaw_rate_in_degrees != CartesianAngularVelocityComponentValue::UNAVAILABLE) {
    // limit value range
    if (yaw_rate_in_degrees < CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE;
    } else if (yaw_rate_in_degrees > CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE;
    }
  }
  object.z_angular_velocity.value.value = yaw_rate_in_degrees;
  object.z_angular_velocity.confidence.value = confidence;
  object.z_angular_velocity_is_present = true;
}
 
inline void setObjectDimension(ObjectDimension& dimension, const uint16_t value,
                               const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  // limit value range
  if (value < ObjectDimensionValue::MIN || value > ObjectDimensionValue::MAX) {
    dimension.value.value = ObjectDimensionValue::OUT_OF_RANGE;
  } else {
    dimension.value.value = value;
  }
 
  // limit confidence range
  if (confidence > ObjectDimensionConfidence::MAX || confidence < ObjectDimensionConfidence::MIN) {
    dimension.confidence.value = ObjectDimensionConfidence::OUT_OF_RANGE;
  } else {
    dimension.confidence.value = confidence;
  }
}
 
inline void setXDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_x, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_x_is_present = true;
}
 
inline void setYDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_y, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_y_is_present = true;
}
 
inline void setZDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_z, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_z_is_present = true;
}
 
inline void setDimensionsOfPerceivedObject(PerceivedObject& object, const gm::Vector3& dimensions,
                                           const uint8_t x_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t y_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t z_confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setXDimensionOfPerceivedObject(object, dimensions.x, x_confidence);
  setYDimensionOfPerceivedObject(object, dimensions.y, y_confidence);
  setZDimensionOfPerceivedObject(object, dimensions.z, z_confidence);
}
 
inline void initPerceivedObject(PerceivedObject& object, const gm::Point& point, const int16_t delta_time = 0) {
  setPositionOfPerceivedObject(object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectWithUTMPosition(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                               const gm::PointStamped& point, const int16_t delta_time = 0) {
  setUTMPositionOfPerceivedObject(cpm, object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectContainer(WrappedCpmContainer& container, const uint8_t n_objects = 0) {
  container.container_id.value = CpmContainerId::PERCEIVED_OBJECT_CONTAINER;
  container.container_data.choice = container.container_id;
  container.container_data.perceived_object_container.number_of_perceived_objects.value = n_objects;
}
 
inline void addPerceivedObjectToContainer(WrappedCpmContainer& container, const PerceivedObject& perceived_object) {
  if (container.container_id.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER &&
      container.container_data.choice.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER) {
    container.container_data.perceived_object_container.perceived_objects.array.push_back(perceived_object);
    container.container_data.perceived_object_container.number_of_perceived_objects.value =
        container.container_data.perceived_object_container.perceived_objects.array.size();
  } else {
    throw std::invalid_argument("Container is not a PerceivedObjectContainer");
  }
}
 
inline void addContainerToCPM(CollectivePerceptionMessage& cpm, const WrappedCpmContainer& container) {
  // check for maximum number of containers
  if (cpm.payload.cpm_containers.value.array.size() < WrappedCpmContainers::MAX_SIZE) {
    cpm.payload.cpm_containers.value.array.push_back(container);
  } else {
    throw std::invalid_argument("Maximum number of CPM-Containers reached");
  }
}
 
}  // namespace etsi_its_cpm_ts_msgs::access

initPerceivedObjectContainer()

void etsi_its_cpm_ts_msgs::access::initPerceivedObjectContainer ( WrappedCpmContainer & container, const uint8_t n_objects = 0 )

inline

Initializes a WrappedCpmContainer as a PerceivedObjectContainer with the given number of objects.

This function sets the container ID to PERCEIVED_OBJECT_CONTAINER and initializes the number of perceived objects in the container to the specified value.

Parameters

container	A reference to the WrappedCpmContainer to be initialized as a PerceivedObjectContainer.
n_objects	The number of perceived objects to initialize in the container. Default is 0.

Definition at line 675 of file cpm_ts_setters.h.

                                     {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v2-1-1_setters.h>
 
inline void setItsPduHeader(CollectivePerceptionMessage& cpm, const uint32_t station_id,
                            const uint8_t protocol_version = 0) {
  setItsPduHeader(cpm.header, MessageId::CPM, station_id, protocol_version);
}
 
inline void setReferenceTime(
    CollectivePerceptionMessage& cpm, const uint64_t unix_nanosecs,
    const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.end()->second) {
  TimestampIts t_its;
  setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
  throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
  cpm.payload.management_container.reference_time = t_its;
}
 
inline void setReferencePosition(CollectivePerceptionMessage& cpm, const double latitude, const double longitude,
                                 const double altitude = AltitudeValue::UNAVAILABLE) {
  setReferencePosition(cpm.payload.management_container.reference_position, latitude, longitude, altitude);
}
 
inline void setFromUTMPosition(CollectivePerceptionMessage& cpm, const gm::PointStamped& utm_position, const int& zone,
                               const bool& northp) {
  setFromUTMPosition(cpm.payload.management_container.reference_position, utm_position, zone, northp);
}
 
inline void setIdOfPerceivedObject(PerceivedObject& object, const uint16_t id) {
  object.object_id.value = id;
  object.object_id_is_present = true;
}
 
inline void setMeasurementDeltaTimeOfPerceivedObject(PerceivedObject& object, const int16_t delta_time = 0) {
  if (delta_time < DeltaTimeMilliSecondSigned::MIN || delta_time > DeltaTimeMilliSecondSigned::MAX) {
    throw std::invalid_argument("MeasurementDeltaTime out of range");
  } else {
    object.measurement_delta_time.value = delta_time;
  }
}
 
inline void setCartesianCoordinateWithConfidence(CartesianCoordinateWithConfidence& coordinate, const int32_t value,
                                                 const uint16_t confidence = CoordinateConfidence::UNAVAILABLE) {
  // limit value range
  if (value < CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE;
  } else if (value > CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE;
  } else {
    coordinate.value.value = value;
  }
 
  // limit confidence range
  if (confidence > CoordinateConfidence::MAX || confidence < CoordinateConfidence::MIN) {
    coordinate.confidence.value = CoordinateConfidence::OUT_OF_RANGE;
  } else {
    coordinate.confidence.value = confidence;
  }
}
 
inline void setPositionOfPerceivedObject(PerceivedObject& object, const gm::Point& point,
                                         const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  setCartesianCoordinateWithConfidence(object.position.x_coordinate, point.x * 100, x_confidence * 100);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate, point.y * 100, y_confidence * 100);
  if (point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate, point.z * 100, z_confidence * 100);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setUTMPositionOfPerceivedObject(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                            const gm::PointStamped& utm_position,
                                            const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  gm::PointStamped reference_position = getUTMPosition(cpm);
  if (utm_position.header.frame_id != reference_position.header.frame_id) {
    throw std::invalid_argument("UTM-Position frame_id (" + utm_position.header.frame_id +
                                ") does not match the reference position frame_id (" + reference_position.header.frame_id +
                                ")");
  }
  setCartesianCoordinateWithConfidence(object.position.x_coordinate,
                                       (utm_position.point.x - reference_position.point.x) * 100, x_confidence);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate,
                                       (utm_position.point.y - reference_position.point.y) * 100, y_confidence);
  if (utm_position.point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate,
                                         (utm_position.point.z - reference_position.point.z) * 100, z_confidence);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setVelocityComponent(VelocityComponent& velocity, const int16_t value,
                                 const uint8_t confidence = SpeedConfidence::UNAVAILABLE) {
  // limit value range
  if (value < VelocityComponentValue::NEGATIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > VelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::POSITIVE_OUT_OF_RANGE;
  } else {
    velocity.value.value = value;
  }
 
  // limit confidence range
  if (confidence > SpeedConfidence::MAX || confidence < SpeedConfidence::MIN) {
    velocity.confidence.value = SpeedConfidence::OUT_OF_RANGE;
  } else {
    velocity.confidence.value = confidence;
  }
}
 
inline void setVelocityOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_velocity,
                                         const uint8_t x_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t y_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t z_confidence = SpeedConfidence::UNAVAILABLE) {
  object.velocity.choice = Velocity3dWithConfidence::CHOICE_CARTESIAN_VELOCITY;
  setVelocityComponent(object.velocity.cartesian_velocity.x_velocity, cartesian_velocity.x * 100, x_confidence * 100);
  setVelocityComponent(object.velocity.cartesian_velocity.y_velocity, cartesian_velocity.y * 100, y_confidence * 100);
  if (cartesian_velocity.z != 0.0) {
    setVelocityComponent(object.velocity.cartesian_velocity.z_velocity, cartesian_velocity.z * 100, z_confidence * 100);
    object.velocity.cartesian_velocity.z_velocity_is_present = true;
  }
  object.velocity_is_present = true;
}
 
inline void setAccelerationComponent(AccelerationComponent& acceleration, const int16_t value,
                                     const uint8_t confidence = AccelerationConfidence::UNAVAILABLE) {
  // limit value range
  if (value < AccelerationValue::NEGATIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > AccelerationValue::POSITIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::POSITIVE_OUT_OF_RANGE;
  } else {
    acceleration.value.value = value;
  }
 
  // limit confidence range
  if (confidence > AccelerationConfidence::MAX || confidence < AccelerationConfidence::MIN) {
    acceleration.confidence.value = AccelerationConfidence::OUT_OF_RANGE;
  } else {
    acceleration.confidence.value = confidence;
  }
}
 
inline void setAccelerationOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_acceleration,
                                             const uint8_t x_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t y_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t z_confidence = AccelerationConfidence::UNAVAILABLE) {
  object.acceleration.choice = Acceleration3dWithConfidence::CHOICE_CARTESIAN_ACCELERATION;
  setAccelerationComponent(object.acceleration.cartesian_acceleration.x_acceleration, cartesian_acceleration.x * 10,
                           x_confidence * 10);
  setAccelerationComponent(object.acceleration.cartesian_acceleration.y_acceleration, cartesian_acceleration.y * 10,
                           y_confidence * 10);
  if (cartesian_acceleration.z != 0.0) {
    setAccelerationComponent(object.acceleration.cartesian_acceleration.z_acceleration, cartesian_acceleration.z * 10,
                             z_confidence * 10);
    object.acceleration.cartesian_acceleration.z_acceleration_is_present = true;
  }
  object.acceleration_is_present = true;
}
 
inline void setYawOfPerceivedObject(PerceivedObject& object, const double yaw,
                                    const uint8_t confidence = AngleConfidence::UNAVAILABLE) {
  // wrap angle to range [0, 360]
  double yaw_in_degrees = yaw * 180 / M_PI + 180;  // TODO: check if this is correct
  while (yaw_in_degrees > 360.0) yaw_in_degrees -= 360.0;
  while (yaw_in_degrees < 0) yaw_in_degrees += 360.0;
  object.angles.z_angle.value.value = yaw_in_degrees * 10;
 
  if (confidence > AngleConfidence::MAX || confidence < AngleConfidence::MIN) {
    object.angles.z_angle.confidence.value = AngleConfidence::OUT_OF_RANGE;
  } else {
    object.angles.z_angle.confidence.value = confidence;
  }
  object.angles_is_present = true;
}
 
inline void setYawRateOfPerceivedObject(PerceivedObject& object, const double yaw_rate,
                                        const uint8_t confidence = AngularSpeedConfidence::UNAVAILABLE) {
  int16_t yaw_rate_in_degrees = yaw_rate * 180 / M_PI;
  if (yaw_rate_in_degrees != CartesianAngularVelocityComponentValue::UNAVAILABLE) {
    // limit value range
    if (yaw_rate_in_degrees < CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE;
    } else if (yaw_rate_in_degrees > CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE;
    }
  }
  object.z_angular_velocity.value.value = yaw_rate_in_degrees;
  object.z_angular_velocity.confidence.value = confidence;
  object.z_angular_velocity_is_present = true;
}
 
inline void setObjectDimension(ObjectDimension& dimension, const uint16_t value,
                               const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  // limit value range
  if (value < ObjectDimensionValue::MIN || value > ObjectDimensionValue::MAX) {
    dimension.value.value = ObjectDimensionValue::OUT_OF_RANGE;
  } else {
    dimension.value.value = value;
  }
 
  // limit confidence range
  if (confidence > ObjectDimensionConfidence::MAX || confidence < ObjectDimensionConfidence::MIN) {
    dimension.confidence.value = ObjectDimensionConfidence::OUT_OF_RANGE;
  } else {
    dimension.confidence.value = confidence;
  }
}
 
inline void setXDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_x, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_x_is_present = true;
}
 
inline void setYDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_y, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_y_is_present = true;
}
 
inline void setZDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_z, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_z_is_present = true;
}
 
inline void setDimensionsOfPerceivedObject(PerceivedObject& object, const gm::Vector3& dimensions,
                                           const uint8_t x_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t y_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t z_confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setXDimensionOfPerceivedObject(object, dimensions.x, x_confidence);
  setYDimensionOfPerceivedObject(object, dimensions.y, y_confidence);
  setZDimensionOfPerceivedObject(object, dimensions.z, z_confidence);
}
 
inline void initPerceivedObject(PerceivedObject& object, const gm::Point& point, const int16_t delta_time = 0) {
  setPositionOfPerceivedObject(object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectWithUTMPosition(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                               const gm::PointStamped& point, const int16_t delta_time = 0) {
  setUTMPositionOfPerceivedObject(cpm, object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectContainer(WrappedCpmContainer& container, const uint8_t n_objects = 0) {
  container.container_id.value = CpmContainerId::PERCEIVED_OBJECT_CONTAINER;
  container.container_data.choice = container.container_id;
  container.container_data.perceived_object_container.number_of_perceived_objects.value = n_objects;
}
 
inline void addPerceivedObjectToContainer(WrappedCpmContainer& container, const PerceivedObject& perceived_object) {
  if (container.container_id.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER &&
      container.container_data.choice.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER) {
    container.container_data.perceived_object_container.perceived_objects.array.push_back(perceived_object);
    container.container_data.perceived_object_container.number_of_perceived_objects.value =
        container.container_data.perceived_object_container.perceived_objects.array.size();
  } else {
    throw std::invalid_argument("Container is not a PerceivedObjectContainer");
  }
}
 
inline void addContainerToCPM(CollectivePerceptionMessage& cpm, const WrappedCpmContainer& container) {
  // check for maximum number of containers
  if (cpm.payload.cpm_containers.value.array.size() < WrappedCpmContainers::MAX_SIZE) {
    cpm.payload.cpm_containers.value.array.push_back(container);
  } else {
    throw std::invalid_argument("Maximum number of CPM-Containers reached");
  }
}
 
}  // namespace etsi_its_cpm_ts_msgs::access

initPerceivedObjectWithUTMPosition()

void etsi_its_cpm_ts_msgs::access::initPerceivedObjectWithUTMPosition ( CollectivePerceptionMessage & cpm, PerceivedObject & object, const gm::PointStamped & point, const int16_t delta_time = 0 )

inline

Initializes a PerceivedObject with the given point (utm-position) and delta time.

This function initializes a PerceivedObject within a position and measurement delta time. It sets the position of a perceived object using the provided UTM position and the CPM's reference position. It sets the measurement delta time using the provided delta_time value.

Parameters

cpm	The CPM to get the reference position from.
object	The PerceivedObject to be initialized.
point	The gm::PointStamped representing the UTM position of the object including the frame_id (utm_<zone><N/S>).
delta_time	The measurement delta time in milliseconds (default: 0).

Definition at line 660 of file cpm_ts_setters.h.

                                     {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v2-1-1_setters.h>
 
inline void setItsPduHeader(CollectivePerceptionMessage& cpm, const uint32_t station_id,
                            const uint8_t protocol_version = 0) {
  setItsPduHeader(cpm.header, MessageId::CPM, station_id, protocol_version);
}
 
inline void setReferenceTime(
    CollectivePerceptionMessage& cpm, const uint64_t unix_nanosecs,
    const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.end()->second) {
  TimestampIts t_its;
  setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
  throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
  cpm.payload.management_container.reference_time = t_its;
}
 
inline void setReferencePosition(CollectivePerceptionMessage& cpm, const double latitude, const double longitude,
                                 const double altitude = AltitudeValue::UNAVAILABLE) {
  setReferencePosition(cpm.payload.management_container.reference_position, latitude, longitude, altitude);
}
 
inline void setFromUTMPosition(CollectivePerceptionMessage& cpm, const gm::PointStamped& utm_position, const int& zone,
                               const bool& northp) {
  setFromUTMPosition(cpm.payload.management_container.reference_position, utm_position, zone, northp);
}
 
inline void setIdOfPerceivedObject(PerceivedObject& object, const uint16_t id) {
  object.object_id.value = id;
  object.object_id_is_present = true;
}
 
inline void setMeasurementDeltaTimeOfPerceivedObject(PerceivedObject& object, const int16_t delta_time = 0) {
  if (delta_time < DeltaTimeMilliSecondSigned::MIN || delta_time > DeltaTimeMilliSecondSigned::MAX) {
    throw std::invalid_argument("MeasurementDeltaTime out of range");
  } else {
    object.measurement_delta_time.value = delta_time;
  }
}
 
inline void setCartesianCoordinateWithConfidence(CartesianCoordinateWithConfidence& coordinate, const int32_t value,
                                                 const uint16_t confidence = CoordinateConfidence::UNAVAILABLE) {
  // limit value range
  if (value < CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE;
  } else if (value > CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE;
  } else {
    coordinate.value.value = value;
  }
 
  // limit confidence range
  if (confidence > CoordinateConfidence::MAX || confidence < CoordinateConfidence::MIN) {
    coordinate.confidence.value = CoordinateConfidence::OUT_OF_RANGE;
  } else {
    coordinate.confidence.value = confidence;
  }
}
 
inline void setPositionOfPerceivedObject(PerceivedObject& object, const gm::Point& point,
                                         const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  setCartesianCoordinateWithConfidence(object.position.x_coordinate, point.x * 100, x_confidence * 100);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate, point.y * 100, y_confidence * 100);
  if (point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate, point.z * 100, z_confidence * 100);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setUTMPositionOfPerceivedObject(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                            const gm::PointStamped& utm_position,
                                            const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  gm::PointStamped reference_position = getUTMPosition(cpm);
  if (utm_position.header.frame_id != reference_position.header.frame_id) {
    throw std::invalid_argument("UTM-Position frame_id (" + utm_position.header.frame_id +
                                ") does not match the reference position frame_id (" + reference_position.header.frame_id +
                                ")");
  }
  setCartesianCoordinateWithConfidence(object.position.x_coordinate,
                                       (utm_position.point.x - reference_position.point.x) * 100, x_confidence);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate,
                                       (utm_position.point.y - reference_position.point.y) * 100, y_confidence);
  if (utm_position.point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate,
                                         (utm_position.point.z - reference_position.point.z) * 100, z_confidence);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setVelocityComponent(VelocityComponent& velocity, const int16_t value,
                                 const uint8_t confidence = SpeedConfidence::UNAVAILABLE) {
  // limit value range
  if (value < VelocityComponentValue::NEGATIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > VelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::POSITIVE_OUT_OF_RANGE;
  } else {
    velocity.value.value = value;
  }
 
  // limit confidence range
  if (confidence > SpeedConfidence::MAX || confidence < SpeedConfidence::MIN) {
    velocity.confidence.value = SpeedConfidence::OUT_OF_RANGE;
  } else {
    velocity.confidence.value = confidence;
  }
}
 
inline void setVelocityOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_velocity,
                                         const uint8_t x_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t y_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t z_confidence = SpeedConfidence::UNAVAILABLE) {
  object.velocity.choice = Velocity3dWithConfidence::CHOICE_CARTESIAN_VELOCITY;
  setVelocityComponent(object.velocity.cartesian_velocity.x_velocity, cartesian_velocity.x * 100, x_confidence * 100);
  setVelocityComponent(object.velocity.cartesian_velocity.y_velocity, cartesian_velocity.y * 100, y_confidence * 100);
  if (cartesian_velocity.z != 0.0) {
    setVelocityComponent(object.velocity.cartesian_velocity.z_velocity, cartesian_velocity.z * 100, z_confidence * 100);
    object.velocity.cartesian_velocity.z_velocity_is_present = true;
  }
  object.velocity_is_present = true;
}
 
inline void setAccelerationComponent(AccelerationComponent& acceleration, const int16_t value,
                                     const uint8_t confidence = AccelerationConfidence::UNAVAILABLE) {
  // limit value range
  if (value < AccelerationValue::NEGATIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > AccelerationValue::POSITIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::POSITIVE_OUT_OF_RANGE;
  } else {
    acceleration.value.value = value;
  }
 
  // limit confidence range
  if (confidence > AccelerationConfidence::MAX || confidence < AccelerationConfidence::MIN) {
    acceleration.confidence.value = AccelerationConfidence::OUT_OF_RANGE;
  } else {
    acceleration.confidence.value = confidence;
  }
}
 
inline void setAccelerationOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_acceleration,
                                             const uint8_t x_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t y_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t z_confidence = AccelerationConfidence::UNAVAILABLE) {
  object.acceleration.choice = Acceleration3dWithConfidence::CHOICE_CARTESIAN_ACCELERATION;
  setAccelerationComponent(object.acceleration.cartesian_acceleration.x_acceleration, cartesian_acceleration.x * 10,
                           x_confidence * 10);
  setAccelerationComponent(object.acceleration.cartesian_acceleration.y_acceleration, cartesian_acceleration.y * 10,
                           y_confidence * 10);
  if (cartesian_acceleration.z != 0.0) {
    setAccelerationComponent(object.acceleration.cartesian_acceleration.z_acceleration, cartesian_acceleration.z * 10,
                             z_confidence * 10);
    object.acceleration.cartesian_acceleration.z_acceleration_is_present = true;
  }
  object.acceleration_is_present = true;
}
 
inline void setYawOfPerceivedObject(PerceivedObject& object, const double yaw,
                                    const uint8_t confidence = AngleConfidence::UNAVAILABLE) {
  // wrap angle to range [0, 360]
  double yaw_in_degrees = yaw * 180 / M_PI + 180;  // TODO: check if this is correct
  while (yaw_in_degrees > 360.0) yaw_in_degrees -= 360.0;
  while (yaw_in_degrees < 0) yaw_in_degrees += 360.0;
  object.angles.z_angle.value.value = yaw_in_degrees * 10;
 
  if (confidence > AngleConfidence::MAX || confidence < AngleConfidence::MIN) {
    object.angles.z_angle.confidence.value = AngleConfidence::OUT_OF_RANGE;
  } else {
    object.angles.z_angle.confidence.value = confidence;
  }
  object.angles_is_present = true;
}
 
inline void setYawRateOfPerceivedObject(PerceivedObject& object, const double yaw_rate,
                                        const uint8_t confidence = AngularSpeedConfidence::UNAVAILABLE) {
  int16_t yaw_rate_in_degrees = yaw_rate * 180 / M_PI;
  if (yaw_rate_in_degrees != CartesianAngularVelocityComponentValue::UNAVAILABLE) {
    // limit value range
    if (yaw_rate_in_degrees < CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE;
    } else if (yaw_rate_in_degrees > CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE;
    }
  }
  object.z_angular_velocity.value.value = yaw_rate_in_degrees;
  object.z_angular_velocity.confidence.value = confidence;
  object.z_angular_velocity_is_present = true;
}
 
inline void setObjectDimension(ObjectDimension& dimension, const uint16_t value,
                               const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  // limit value range
  if (value < ObjectDimensionValue::MIN || value > ObjectDimensionValue::MAX) {
    dimension.value.value = ObjectDimensionValue::OUT_OF_RANGE;
  } else {
    dimension.value.value = value;
  }
 
  // limit confidence range
  if (confidence > ObjectDimensionConfidence::MAX || confidence < ObjectDimensionConfidence::MIN) {
    dimension.confidence.value = ObjectDimensionConfidence::OUT_OF_RANGE;
  } else {
    dimension.confidence.value = confidence;
  }
}
 
inline void setXDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_x, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_x_is_present = true;
}
 
inline void setYDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_y, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_y_is_present = true;
}
 
inline void setZDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_z, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_z_is_present = true;
}
 
inline void setDimensionsOfPerceivedObject(PerceivedObject& object, const gm::Vector3& dimensions,
                                           const uint8_t x_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t y_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t z_confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setXDimensionOfPerceivedObject(object, dimensions.x, x_confidence);
  setYDimensionOfPerceivedObject(object, dimensions.y, y_confidence);
  setZDimensionOfPerceivedObject(object, dimensions.z, z_confidence);
}
 
inline void initPerceivedObject(PerceivedObject& object, const gm::Point& point, const int16_t delta_time = 0) {
  setPositionOfPerceivedObject(object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectWithUTMPosition(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                               const gm::PointStamped& point, const int16_t delta_time = 0) {
  setUTMPositionOfPerceivedObject(cpm, object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectContainer(WrappedCpmContainer& container, const uint8_t n_objects = 0) {
  container.container_id.value = CpmContainerId::PERCEIVED_OBJECT_CONTAINER;
  container.container_data.choice = container.container_id;
  container.container_data.perceived_object_container.number_of_perceived_objects.value = n_objects;
}
 
inline void addPerceivedObjectToContainer(WrappedCpmContainer& container, const PerceivedObject& perceived_object) {
  if (container.container_id.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER &&
      container.container_data.choice.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER) {
    container.container_data.perceived_object_container.perceived_objects.array.push_back(perceived_object);
    container.container_data.perceived_object_container.number_of_perceived_objects.value =
        container.container_data.perceived_object_container.perceived_objects.array.size();
  } else {
    throw std::invalid_argument("Container is not a PerceivedObjectContainer");
  }
}
 
inline void addContainerToCPM(CollectivePerceptionMessage& cpm, const WrappedCpmContainer& container) {
  // check for maximum number of containers
  if (cpm.payload.cpm_containers.value.array.size() < WrappedCpmContainers::MAX_SIZE) {
    cpm.payload.cpm_containers.value.array.push_back(container);
  } else {
    throw std::invalid_argument("Maximum number of CPM-Containers reached");
  }
}
 
}  // namespace etsi_its_cpm_ts_msgs::access

setAccelerationComponent()

void etsi_its_cpm_ts_msgs::access::setAccelerationComponent ( AccelerationComponent & acceleration, const int16_t value, const uint8_t confidence = AccelerationConfidence::UNAVAILABLE )

inline

Sets the value and confidence of a AccelerationComponent.

This function sets the value and confidence of a AccelerationComponent object. The value is limited to a specific range, and the confidence is limited to a specific range as well. If the provided value or confidence is out of range, it will be set to the corresponding out-of-range value.

Parameters

acceleration	The AccelerationComponent object to set the value and confidence for.
value	The value to set for the AccelerationComponent in dm/s^2.
confidence	The confidence to set for the AccelerationComponent in dm/s^2. Default value is AccelerationConfidence::UNAVAILABLE.

Definition at line 434 of file cpm_ts_setters.h.

                                                                                                            {
  setObjectDimension(object.object_dimension_x, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_x_is_present = true;
}
 

setAccelerationOfPerceivedObject()

void etsi_its_cpm_ts_msgs::access::setAccelerationOfPerceivedObject ( PerceivedObject & object, const gm::Vector3 & cartesian_acceleration, const uint8_t x_confidence = AccelerationConfidence::UNAVAILABLE, const uint8_t y_confidence = AccelerationConfidence::UNAVAILABLE, const uint8_t z_confidence = AccelerationConfidence::UNAVAILABLE )

inline

Sets the acceleration of a perceived object.

This function sets the acceleration of a perceived object using the provided Cartesian acceleration components. Optionally, confidence values can be specified for each acceleration component.

Parameters

object	The perceived object for which the acceleration is being set.
cartesian_acceleration	The Cartesian acceleration components (x, y, z) of the object (in m/s^2).
x_confidence	The confidence value in m/s^2 for the x acceleration component (default: AccelerationConfidence::UNAVAILABLE).
y_confidence	The confidence value in m/s^2 for the y acceleration component (default: AccelerationConfidence::UNAVAILABLE).
z_confidence	The confidence value in m/s^2 for the z acceleration component (default: AccelerationConfidence::UNAVAILABLE).

Definition at line 465 of file cpm_ts_setters.h.

                                                                                                            {
  setObjectDimension(object.object_dimension_z, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_z_is_present = true;
}
 

setAltitude()

void etsi_its_cpm_ts_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 140 of file cpm_ts_setters.h.

setAltitudeValue()

void etsi_its_cpm_ts_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 121 of file cpm_ts_setters.h.

setBitString()

template<typename T >

void etsi_its_cpm_ts_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 232 of file cpm_ts_setters.h.

                                                                                        {
  // limit value range
  if (value < VelocityComponentValue::NEGATIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > VelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::POSITIVE_OUT_OF_RANGE;
  } else {
    velocity.value.value = value;
  }
 
  // limit confidence range
  if (confidence > SpeedConfidence::MAX || confidence < SpeedConfidence::MIN) {

setCartesianCoordinateWithConfidence()

void etsi_its_cpm_ts_msgs::access::setCartesianCoordinateWithConfidence ( CartesianCoordinateWithConfidence & coordinate, const int32_t value, const uint16_t confidence = CoordinateConfidence::UNAVAILABLE )

inline

Sets the value and confidence of a CartesianCoordinateWithConfidence object.

This function sets the value and confidence of a CartesianCoordinateWithConfidence object. The value is limited to the range defined by CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE and CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE. The confidence is limited to the range defined by CoordinateConfidence::MIN and CoordinateConfidence::MAX. If the provided confidence is out of range, the confidence value is set to CoordinateConfidence::OUT_OF_RANGE.

Parameters

coordinate	The CartesianCoordinateWithConfidence object to be modified.
value	The value to be set in centimeters.
confidence	The confidence to be set in centimeters (default: CoordinateConfidence::UNAVAILABLE).

Definition at line 288 of file cpm_ts_setters.h.

                                                                                                   {
  // limit value range
  if (value < AccelerationValue::NEGATIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > AccelerationValue::POSITIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::POSITIVE_OUT_OF_RANGE;
  } else {

setDimensionsOfPerceivedObject()

void etsi_its_cpm_ts_msgs::access::setDimensionsOfPerceivedObject ( PerceivedObject & object, const gm::Vector3 & dimensions, const uint8_t x_confidence = ObjectDimensionConfidence::UNAVAILABLE, const uint8_t y_confidence = ObjectDimensionConfidence::UNAVAILABLE, const uint8_t z_confidence = ObjectDimensionConfidence::UNAVAILABLE )

inline

Sets all dimensions of a perceived object.

This function sets the dimensions of a perceived object using the provided dimensions and confidence values.

Parameters

object	The perceived object to set the dimensions for.
dimensions	The dimensions of the object as a gm::Vector3 (x, y, z) in meters.
x_confidence	The confidence in meters for the x dimension (optional, default: ObjectDimensionConfidence::UNAVAILABLE).
y_confidence	The confidence in meters for the y dimension (optional, default: ObjectDimensionConfidence::UNAVAILABLE).
z_confidence	The confidence in meters for the z dimension (optional, default: ObjectDimensionConfidence::UNAVAILABLE).

Definition at line 625 of file cpm_ts_setters.h.

                                     {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v2-1-1_setters.h>
 
inline void setItsPduHeader(CollectivePerceptionMessage& cpm, const uint32_t station_id,
                            const uint8_t protocol_version = 0) {
  setItsPduHeader(cpm.header, MessageId::CPM, station_id, protocol_version);
}
 
inline void setReferenceTime(
    CollectivePerceptionMessage& cpm, const uint64_t unix_nanosecs,
    const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.end()->second) {
  TimestampIts t_its;
  setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
  throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
  cpm.payload.management_container.reference_time = t_its;
}
 
inline void setReferencePosition(CollectivePerceptionMessage& cpm, const double latitude, const double longitude,
                                 const double altitude = AltitudeValue::UNAVAILABLE) {
  setReferencePosition(cpm.payload.management_container.reference_position, latitude, longitude, altitude);
}
 
inline void setFromUTMPosition(CollectivePerceptionMessage& cpm, const gm::PointStamped& utm_position, const int& zone,
                               const bool& northp) {
  setFromUTMPosition(cpm.payload.management_container.reference_position, utm_position, zone, northp);
}
 
inline void setIdOfPerceivedObject(PerceivedObject& object, const uint16_t id) {
  object.object_id.value = id;
  object.object_id_is_present = true;
}
 
inline void setMeasurementDeltaTimeOfPerceivedObject(PerceivedObject& object, const int16_t delta_time = 0) {
  if (delta_time < DeltaTimeMilliSecondSigned::MIN || delta_time > DeltaTimeMilliSecondSigned::MAX) {
    throw std::invalid_argument("MeasurementDeltaTime out of range");
  } else {
    object.measurement_delta_time.value = delta_time;
  }
}
 
inline void setCartesianCoordinateWithConfidence(CartesianCoordinateWithConfidence& coordinate, const int32_t value,
                                                 const uint16_t confidence = CoordinateConfidence::UNAVAILABLE) {
  // limit value range
  if (value < CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE;
  } else if (value > CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE;
  } else {
    coordinate.value.value = value;
  }
 
  // limit confidence range
  if (confidence > CoordinateConfidence::MAX || confidence < CoordinateConfidence::MIN) {
    coordinate.confidence.value = CoordinateConfidence::OUT_OF_RANGE;
  } else {
    coordinate.confidence.value = confidence;
  }
}
 
inline void setPositionOfPerceivedObject(PerceivedObject& object, const gm::Point& point,
                                         const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  setCartesianCoordinateWithConfidence(object.position.x_coordinate, point.x * 100, x_confidence * 100);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate, point.y * 100, y_confidence * 100);
  if (point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate, point.z * 100, z_confidence * 100);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setUTMPositionOfPerceivedObject(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                            const gm::PointStamped& utm_position,
                                            const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  gm::PointStamped reference_position = getUTMPosition(cpm);
  if (utm_position.header.frame_id != reference_position.header.frame_id) {
    throw std::invalid_argument("UTM-Position frame_id (" + utm_position.header.frame_id +
                                ") does not match the reference position frame_id (" + reference_position.header.frame_id +
                                ")");
  }
  setCartesianCoordinateWithConfidence(object.position.x_coordinate,
                                       (utm_position.point.x - reference_position.point.x) * 100, x_confidence);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate,
                                       (utm_position.point.y - reference_position.point.y) * 100, y_confidence);
  if (utm_position.point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate,
                                         (utm_position.point.z - reference_position.point.z) * 100, z_confidence);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setVelocityComponent(VelocityComponent& velocity, const int16_t value,
                                 const uint8_t confidence = SpeedConfidence::UNAVAILABLE) {
  // limit value range
  if (value < VelocityComponentValue::NEGATIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > VelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::POSITIVE_OUT_OF_RANGE;
  } else {
    velocity.value.value = value;
  }
 
  // limit confidence range
  if (confidence > SpeedConfidence::MAX || confidence < SpeedConfidence::MIN) {
    velocity.confidence.value = SpeedConfidence::OUT_OF_RANGE;
  } else {
    velocity.confidence.value = confidence;
  }
}
 
inline void setVelocityOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_velocity,
                                         const uint8_t x_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t y_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t z_confidence = SpeedConfidence::UNAVAILABLE) {
  object.velocity.choice = Velocity3dWithConfidence::CHOICE_CARTESIAN_VELOCITY;
  setVelocityComponent(object.velocity.cartesian_velocity.x_velocity, cartesian_velocity.x * 100, x_confidence * 100);
  setVelocityComponent(object.velocity.cartesian_velocity.y_velocity, cartesian_velocity.y * 100, y_confidence * 100);
  if (cartesian_velocity.z != 0.0) {
    setVelocityComponent(object.velocity.cartesian_velocity.z_velocity, cartesian_velocity.z * 100, z_confidence * 100);
    object.velocity.cartesian_velocity.z_velocity_is_present = true;
  }
  object.velocity_is_present = true;
}
 
inline void setAccelerationComponent(AccelerationComponent& acceleration, const int16_t value,
                                     const uint8_t confidence = AccelerationConfidence::UNAVAILABLE) {
  // limit value range
  if (value < AccelerationValue::NEGATIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > AccelerationValue::POSITIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::POSITIVE_OUT_OF_RANGE;
  } else {
    acceleration.value.value = value;
  }
 
  // limit confidence range
  if (confidence > AccelerationConfidence::MAX || confidence < AccelerationConfidence::MIN) {
    acceleration.confidence.value = AccelerationConfidence::OUT_OF_RANGE;
  } else {
    acceleration.confidence.value = confidence;
  }
}
 
inline void setAccelerationOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_acceleration,
                                             const uint8_t x_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t y_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t z_confidence = AccelerationConfidence::UNAVAILABLE) {
  object.acceleration.choice = Acceleration3dWithConfidence::CHOICE_CARTESIAN_ACCELERATION;
  setAccelerationComponent(object.acceleration.cartesian_acceleration.x_acceleration, cartesian_acceleration.x * 10,
                           x_confidence * 10);
  setAccelerationComponent(object.acceleration.cartesian_acceleration.y_acceleration, cartesian_acceleration.y * 10,
                           y_confidence * 10);
  if (cartesian_acceleration.z != 0.0) {
    setAccelerationComponent(object.acceleration.cartesian_acceleration.z_acceleration, cartesian_acceleration.z * 10,
                             z_confidence * 10);
    object.acceleration.cartesian_acceleration.z_acceleration_is_present = true;
  }
  object.acceleration_is_present = true;
}
 
inline void setYawOfPerceivedObject(PerceivedObject& object, const double yaw,
                                    const uint8_t confidence = AngleConfidence::UNAVAILABLE) {
  // wrap angle to range [0, 360]
  double yaw_in_degrees = yaw * 180 / M_PI + 180;  // TODO: check if this is correct
  while (yaw_in_degrees > 360.0) yaw_in_degrees -= 360.0;
  while (yaw_in_degrees < 0) yaw_in_degrees += 360.0;
  object.angles.z_angle.value.value = yaw_in_degrees * 10;
 
  if (confidence > AngleConfidence::MAX || confidence < AngleConfidence::MIN) {
    object.angles.z_angle.confidence.value = AngleConfidence::OUT_OF_RANGE;
  } else {
    object.angles.z_angle.confidence.value = confidence;
  }
  object.angles_is_present = true;
}
 
inline void setYawRateOfPerceivedObject(PerceivedObject& object, const double yaw_rate,
                                        const uint8_t confidence = AngularSpeedConfidence::UNAVAILABLE) {
  int16_t yaw_rate_in_degrees = yaw_rate * 180 / M_PI;
  if (yaw_rate_in_degrees != CartesianAngularVelocityComponentValue::UNAVAILABLE) {
    // limit value range
    if (yaw_rate_in_degrees < CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE;
    } else if (yaw_rate_in_degrees > CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE;
    }
  }
  object.z_angular_velocity.value.value = yaw_rate_in_degrees;
  object.z_angular_velocity.confidence.value = confidence;
  object.z_angular_velocity_is_present = true;
}
 
inline void setObjectDimension(ObjectDimension& dimension, const uint16_t value,
                               const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  // limit value range
  if (value < ObjectDimensionValue::MIN || value > ObjectDimensionValue::MAX) {
    dimension.value.value = ObjectDimensionValue::OUT_OF_RANGE;
  } else {
    dimension.value.value = value;
  }
 
  // limit confidence range
  if (confidence > ObjectDimensionConfidence::MAX || confidence < ObjectDimensionConfidence::MIN) {
    dimension.confidence.value = ObjectDimensionConfidence::OUT_OF_RANGE;
  } else {
    dimension.confidence.value = confidence;
  }
}
 
inline void setXDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_x, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_x_is_present = true;
}
 
inline void setYDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_y, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_y_is_present = true;
}
 
inline void setZDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_z, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_z_is_present = true;
}
 
inline void setDimensionsOfPerceivedObject(PerceivedObject& object, const gm::Vector3& dimensions,
                                           const uint8_t x_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t y_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t z_confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setXDimensionOfPerceivedObject(object, dimensions.x, x_confidence);
  setYDimensionOfPerceivedObject(object, dimensions.y, y_confidence);
  setZDimensionOfPerceivedObject(object, dimensions.z, z_confidence);
}
 
inline void initPerceivedObject(PerceivedObject& object, const gm::Point& point, const int16_t delta_time = 0) {
  setPositionOfPerceivedObject(object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectWithUTMPosition(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                               const gm::PointStamped& point, const int16_t delta_time = 0) {
  setUTMPositionOfPerceivedObject(cpm, object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectContainer(WrappedCpmContainer& container, const uint8_t n_objects = 0) {
  container.container_id.value = CpmContainerId::PERCEIVED_OBJECT_CONTAINER;
  container.container_data.choice = container.container_id;
  container.container_data.perceived_object_container.number_of_perceived_objects.value = n_objects;
}
 
inline void addPerceivedObjectToContainer(WrappedCpmContainer& container, const PerceivedObject& perceived_object) {
  if (container.container_id.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER &&
      container.container_data.choice.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER) {
    container.container_data.perceived_object_container.perceived_objects.array.push_back(perceived_object);
    container.container_data.perceived_object_container.number_of_perceived_objects.value =
        container.container_data.perceived_object_container.perceived_objects.array.size();
  } else {
    throw std::invalid_argument("Container is not a PerceivedObjectContainer");
  }
}
 
inline void addContainerToCPM(CollectivePerceptionMessage& cpm, const WrappedCpmContainer& container) {
  // check for maximum number of containers
  if (cpm.payload.cpm_containers.value.array.size() < WrappedCpmContainers::MAX_SIZE) {
    cpm.payload.cpm_containers.value.array.push_back(container);
  } else {
    throw std::invalid_argument("Maximum number of CPM-Containers reached");
  }
}
 
}  // namespace etsi_its_cpm_ts_msgs::access

setFromUTMPosition() [1/2]

void etsi_its_cpm_ts_msgs::access::setFromUTMPosition ( CollectivePerceptionMessage & cpm, const gm::PointStamped & utm_position, const int & zone, const bool & northp )

inline

Set the ReferencePosition of a CPM 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]	cpm	CPM for which to set the ReferencePosition
[in]	utm_position	geometry_msgs::PointStamped describing the given utm position in meters
[in]	zone	the UTM zone (zero means UPS) of the given position
[in]	northp	hemisphere (true means north, false means south)

Definition at line 238 of file cpm_ts_setters.h.

setFromUTMPosition() [2/2]

template<typename T >

void etsi_its_cpm_ts_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 208 of file cpm_ts_setters.h.

                                                                                                           {
  gm::PointStamped reference_position = getUTMPosition(cpm);
  if (utm_position.header.frame_id != reference_position.header.frame_id) {
    throw std::invalid_argument("UTM-Position frame_id (" + utm_position.header.frame_id +
                                ") does not match the reference position frame_id (" + reference_position.header.frame_id +
                                ")");
  }
  setCartesianCoordinateWithConfidence(object.position.x_coordinate,
                                       (utm_position.point.x - reference_position.point.x) * 100, x_confidence);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate,

setIdOfPerceivedObject()

void etsi_its_cpm_ts_msgs::access::setIdOfPerceivedObject ( PerceivedObject & object, const uint16_t id )

inline

Set the ID of a PerceivedObject.

Sets the object_id of the PerceivedObject to the given ID.

Parameters

object	PerceivedObject to set the ID for
id	ID to set

Definition at line 251 of file cpm_ts_setters.h.

                                                                          {

setItsPduHeader() [1/2]

void etsi_its_cpm_ts_msgs::access::setItsPduHeader ( CollectivePerceptionMessage & cpm, const uint32_t station_id, const uint8_t protocol_version = 0 )

inline

Sets the ITS PDU header of a CPM.

This function sets the ITS PDU header of a CPM with the provided station ID and protocol version.

Parameters

cpm	The CPM to set the ITS PDU header for.
station_id	The station ID to set in the ITS PDU header.
protocol_version	The protocol version to set in the ITS PDU header. Default is 0.

Definition at line 185 of file cpm_ts_setters.h.

                                                                                                        {
  setCartesianCoordinateWithConfidence(object.position.x_coordinate, point.x * 100, x_confidence * 100);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate, point.y * 100, y_confidence * 100);
  if (point.z != 0.0) {

setItsPduHeader() [2/2]

void etsi_its_cpm_ts_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 94 of file cpm_ts_setters.h.

setLateralAcceleration()

void etsi_its_cpm_ts_msgs::access::setLateralAcceleration ( AccelerationComponent & accel, const double value )

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)

Definition at line 169 of file cpm_ts_setters.h.

setLateralAccelerationValue()

void etsi_its_cpm_ts_msgs::access::setLateralAccelerationValue ( AccelerationValue & 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 150 of file cpm_ts_setters.h.

                                                                     : CoordinateConfidence::UNAVAILABLE).
 */
inline void setCartesianCoordinateWithConfidence(CartesianCoordinateWithConfidence& coordinate, const int32_t value,
                                                 const uint16_t confidence = CoordinateConfidence::UNAVAILABLE) {
  // limit value range
  if (value < CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE;
  } else if (value > CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE;
  } else {

setLatitude()

void etsi_its_cpm_ts_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 97 of file cpm_ts_setters.h.

setLongitude()

void etsi_its_cpm_ts_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 109 of file cpm_ts_setters.h.

setLongitudinalAcceleration()

void etsi_its_cpm_ts_msgs::access::setLongitudinalAcceleration ( AccelerationComponent & accel, const double value )

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)

Definition at line 139 of file cpm_ts_setters.h.

setLongitudinalAccelerationValue()

void etsi_its_cpm_ts_msgs::access::setLongitudinalAccelerationValue ( AccelerationValue & 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 120 of file cpm_ts_setters.h.

setMeasurementDeltaTimeOfPerceivedObject()

void etsi_its_cpm_ts_msgs::access::setMeasurementDeltaTimeOfPerceivedObject ( PerceivedObject & object, const int16_t delta_time = 0 )

inline

Sets the measurement delta time of a PerceivedObject.

This function sets the measurement delta time of a PerceivedObject. The measurement delta time represents the time difference between the reference time of the CPM and the measurement of the object.

Parameters

object	The PerceivedObject to set the measurement delta time for.
delta_time	The measurement delta time to set in milliseconds. Default value is 0.

Exceptions

std::invalid_argument

if the delta_time is out of range.

Definition at line 267 of file cpm_ts_setters.h.

                                                                                        : SpeedConfidence::UNAVAILABLE).
 * @param y_confidence The confidence value in m/s for the y velocity component (default: SpeedConfidence::UNAVAILABLE).
 * @param z_confidence The confidence value in m/s for the z velocity component (default: SpeedConfidence::UNAVAILABLE).
 */
inline void setVelocityOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_velocity,

setObjectDimension()

void etsi_its_cpm_ts_msgs::access::setObjectDimension ( ObjectDimension & dimension, const uint16_t value, const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE )

inline

Sets the object dimension with the given value and confidence.

This function sets the value and confidence of the object dimension based on the provided parameters. The value is limited to the range defined by ObjectDimensionValue::MIN and ObjectDimensionValue::MAX. If the provided value is outside this range, the dimension value is set to ObjectDimensionValue::OUT_OF_RANGE.

The confidence is limited to the range defined by ObjectDimensionConfidence::MIN and ObjectDimensionConfidence::MAX. If the provided confidence is outside this range, the confidence value is set to ObjectDimensionConfidence::OUT_OF_RANGE.

Parameters

dimension	The object dimension to be set.
value	The value of the object dimension in decimeters.
confidence	The confidence of the object dimension in decimeters (optional, default is ObjectDimensionConfidence::UNAVAILABLE).

Definition at line 549 of file cpm_ts_setters.h.

                                                                                                                   {
  if (container.container_id.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER &&
      container.container_data.choice.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER) {
    container.container_data.perceived_object_container.perceived_objects.array.push_back(perceived_object);
    container.container_data.perceived_object_container.number_of_perceived_objects.value =
        container.container_data.perceived_object_container.perceived_objects.array.size();
  } else {

setPositionOfPerceivedObject()

void etsi_its_cpm_ts_msgs::access::setPositionOfPerceivedObject ( PerceivedObject & object, const gm::Point & point, const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE, const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE, const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE )

inline

Sets the position of a perceived object (relative to the CPM's reference position).

This function sets the position of a perceived object using the provided coordinates and confidence values.

Parameters

object	The PerceivedObject to set the position for.
point	The gm::Point representing the coordinates of the object in meters.
x_confidence	The confidence value in meters for the x-coordinate (default: CoordinateConfidence::UNAVAILABLE).
y_confidence	The confidence value in meters for the y-coordinate (default: CoordinateConfidence::UNAVAILABLE).
z_confidence	The confidence value in meters for the z-coordinate (default: CoordinateConfidence::UNAVAILABLE).

Definition at line 318 of file cpm_ts_setters.h.

                                                                                              : AccelerationConfidence::UNAVAILABLE).
 * @param y_confidence The confidence value in m/s^2 for the y acceleration component (default: AccelerationConfidence::UNAVAILABLE).
 * @param z_confidence The confidence value in m/s^2 for the z acceleration component (default: AccelerationConfidence::UNAVAILABLE).
 */

setReferencePosition() [1/2]

void etsi_its_cpm_ts_msgs::access::setReferencePosition ( CollectivePerceptionMessage & cpm, const double latitude, const double longitude, const double altitude = AltitudeValue::UNAVAILABLE )

inline

Set the ReferencePositionWithConfidence for a CPM TS.

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

Parameters

cpm	CPM 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 221 of file cpm_ts_setters.h.

                                   {

setReferencePosition() [2/2]

template<typename T >

void etsi_its_cpm_ts_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 182 of file cpm_ts_setters.h.

                                                                                                        {
  setCartesianCoordinateWithConfidence(object.position.x_coordinate, point.x * 100, x_confidence * 100);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate, point.y * 100, y_confidence * 100);
  if (point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate, point.z * 100, z_confidence * 100);
    object.position.z_coordinate_is_present = true;
  }
}
 

setReferenceTime()

void etsi_its_cpm_ts_msgs::access::setReferenceTime ( CollectivePerceptionMessage & cpm, const uint64_t unix_nanosecs, const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.end()->second )

inline

Sets the reference time in a CPM.

This function sets the reference time in a CPM object. The reference time is represented by a Unix timestamp in nanoseconds including the number of leap seconds. The reference time is stored in the payload management container of the CPM.

Parameters

cpm	The CPM object to set the reference time in.
unix_nanosecs	The Unix timestamp in nanoseconds representing the reference time.
n_leap_seconds	The number of leap seconds to be considered. Defaults to the todays number of leap seconds since 2004.

Definition at line 201 of file cpm_ts_setters.h.

                                                                                   : CoordinateConfidence::UNAVAILABLE).
 * @param y_confidence The confidence value in meters for the y coordinate (default: CoordinateConfidence::UNAVAILABLE).
 * @param z_confidence The confidence value in meters for the z coordinate (default: CoordinateConfidence::UNAVAILABLE).
 *
 * @throws std::invalid_argument if the UTM-Position frame_id does not match the reference position frame_id.
 */

setSpeed()

void etsi_its_cpm_ts_msgs::access::setSpeed ( Speed & speed, const double value )

inline

Set the Speed object.

SpeedConfidence is set to UNAVAILABLE

Parameters

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

Definition at line 165 of file cpm_ts_setters.h.

         {
    coordinate.confidence.value = confidence;
  }

setSpeedValue()

void etsi_its_cpm_ts_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 151 of file cpm_ts_setters.h.

                                                                                                              {
  // limit value range
  if (value < CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE) {

setStationId()

void etsi_its_cpm_ts_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 81 of file cpm_ts_setters.h.

setStationType()

void etsi_its_cpm_ts_msgs::access::setStationType ( TrafficParticipantType & station_type, const uint8_t value )

inline

Set the Station Type.

Parameters

station_type
value

Definition at line 109 of file cpm_ts_setters.h.

setTimestampITS()

void etsi_its_cpm_ts_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.end()->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. (Default: etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.end()->second)
[in]	epoch_offset	Unix-Timestamp in seconds for the 01.01.2004 at 00:00:00

Definition at line 83 of file cpm_ts_setters.h.

                                                                                   {
  setReferencePosition(cpm.payload.management_container.reference_position, latitude, longitude, altitude);
}
 

setUTMPositionOfPerceivedObject()

void etsi_its_cpm_ts_msgs::access::setUTMPositionOfPerceivedObject ( CollectivePerceptionMessage & cpm, PerceivedObject & object, const gm::PointStamped & utm_position, const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE, const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE, const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE )

inline

Sets the position of a perceived object based on a UTM position.

This function sets the position of a perceived object using the provided UTM position and the CPM's reference position. It also allows specifying confidence values for the x, y, and z coordinates.

Parameters

cpm	The CPM to get the reference position from.
object	The PerceivedObject to set the position for.
utm_position	gm::PointStamped representing the UTM position of the object including the frame_id (utm_<zone><N/S>).
x_confidence	The confidence value in meters for the x coordinate (default: CoordinateConfidence::UNAVAILABLE).
y_confidence	The confidence value in meters for the y coordinate (default: CoordinateConfidence::UNAVAILABLE).
z_confidence	The confidence value in meters for the z coordinate (default: CoordinateConfidence::UNAVAILABLE).

Exceptions

std::invalid_argument

if the UTM-Position frame_id does not match the reference position frame_id.

Definition at line 345 of file cpm_ts_setters.h.

                                                                                           {
  // wrap angle to range [0, 360]
  double yaw_in_degrees = yaw * 180 / M_PI + 180;  // TODO: check if this is correct
  while (yaw_in_degrees > 360.0) yaw_in_degrees -= 360.0;
  while (yaw_in_degrees < 0) yaw_in_degrees += 360.0;
  object.angles.z_angle.value.value = yaw_in_degrees * 10;
 
  if (confidence > AngleConfidence::MAX || confidence < AngleConfidence::MIN) {
    object.angles.z_angle.confidence.value = AngleConfidence::OUT_OF_RANGE;

setVelocityComponent()

void etsi_its_cpm_ts_msgs::access::setVelocityComponent ( VelocityComponent & velocity, const int16_t value, const uint8_t confidence = SpeedConfidence::UNAVAILABLE )

inline

Sets the value and confidence of a VelocityComponent.

This function sets the value and confidence of a VelocityComponent object. The value is limited to a specific range, and the confidence is limited to a specific range as well. If the provided value or confidence is out of range, it will be set to the corresponding out-of-range value.

Parameters

velocity	The VelocityComponent object to set the value and confidence for.
value	The value to set for the VelocityComponent in cm/s.
confidence	The confidence to set for the VelocityComponent in cm/s. Default value is SpeedConfidence::UNAVAILABLE.

Definition at line 378 of file cpm_ts_setters.h.

                                                                                                      {
  int16_t yaw_rate_in_degrees = yaw_rate * 180 / M_PI;
  if (yaw_rate_in_degrees != CartesianAngularVelocityComponentValue::UNAVAILABLE) {
    // limit value range
    if (yaw_rate_in_degrees < CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE;
    } else if (yaw_rate_in_degrees > CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE;
    }
  }
  object.z_angular_velocity.value.value = yaw_rate_in_degrees;
  object.z_angular_velocity.confidence.value = confidence;

setVelocityOfPerceivedObject()

void etsi_its_cpm_ts_msgs::access::setVelocityOfPerceivedObject ( PerceivedObject & object, const gm::Vector3 & cartesian_velocity, const uint8_t x_confidence = SpeedConfidence::UNAVAILABLE, const uint8_t y_confidence = SpeedConfidence::UNAVAILABLE, const uint8_t z_confidence = SpeedConfidence::UNAVAILABLE )

inline

Sets the velocity of a perceived object.

This function sets the velocity of a perceived object using the provided Cartesian velocity components. Optionally, confidence values can be specified for each velocity component.

Parameters

object	The perceived object for which the velocity is being set.
cartesian_velocity	The Cartesian velocity components (x, y, z) of the object (in m/s).
x_confidence	The confidence value in m/s for the x velocity component (default: SpeedConfidence::UNAVAILABLE).
y_confidence	The confidence value in m/s for the y velocity component (default: SpeedConfidence::UNAVAILABLE).
z_confidence	The confidence value in m/s for the z velocity component (default: SpeedConfidence::UNAVAILABLE).

Definition at line 409 of file cpm_ts_setters.h.

                                                                                                {
  // limit value range
  if (value < ObjectDimensionValue::MIN || value > ObjectDimensionValue::MAX) {
    dimension.value.value = ObjectDimensionValue::OUT_OF_RANGE;
  } else {
    dimension.value.value = value;
  }
 

setXDimensionOfPerceivedObject()

void etsi_its_cpm_ts_msgs::access::setXDimensionOfPerceivedObject ( PerceivedObject & object, const double value, const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE )

inline

Sets the x-dimension of a perceived object.

This function sets the x-dimension of the given PerceivedObject to the specified value. The x-dimension usually represents the length of the object.

Parameters

object	The PerceivedObject to modify.
value	The value to set as the x-dimension in meters.
confidence	The confidence of the x-dimension value in meters (optional, default is ObjectDimensionConfidence::UNAVAILABLE).

Definition at line 576 of file cpm_ts_setters.h.

setYawOfPerceivedObject()

void etsi_its_cpm_ts_msgs::access::setYawOfPerceivedObject ( PerceivedObject & object, const double yaw, const uint8_t confidence = AngleConfidence::UNAVAILABLE )

inline

Sets the yaw angle of a perceived object.

This function sets the yaw angle of a PerceivedObject. The yaw angle is wrapped to the range [0, 360] degrees. The function also allows specifying the confidence level of the yaw angle.

Parameters

object	The PerceivedObject to set the yaw angle for.
yaw	The yaw angle in radians.
confidence	The confidence level of the yaw angle in 0,1 degrees (optional, default is AngleConfidence::UNAVAILABLE).

Definition at line 492 of file cpm_ts_setters.h.

                                                                                                              {
  setXDimensionOfPerceivedObject(object, dimensions.x, x_confidence);
  setYDimensionOfPerceivedObject(object, dimensions.y, y_confidence);
  setZDimensionOfPerceivedObject(object, dimensions.z, z_confidence);
}
 

setYawRateOfPerceivedObject()

void etsi_its_cpm_ts_msgs::access::setYawRateOfPerceivedObject ( PerceivedObject & object, const double yaw_rate, const uint8_t confidence = AngularSpeedConfidence::UNAVAILABLE )

inline

Sets the yaw rate of a perceived object.

This function sets the yaw rate of a PerceivedObject. The yaw rate is limited to the range defined by CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE and CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE. The function also allows specifying the confidence level of the yaw rate.

Parameters

object	The PerceivedObject to set the yaw rate for.
yaw_rate	The yaw rate in rad/s.
confidence	Confidence of the yaw rate defined in AngularSpeedConfidence (optional, default is AngularSpeedConfidence::UNAVAILABLE).

Definition at line 519 of file cpm_ts_setters.h.

                                                                        : 0).
 */
inline void initPerceivedObjectWithUTMPosition(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                               const gm::PointStamped& point, const int16_t delta_time = 0) {
  setUTMPositionOfPerceivedObject(cpm, object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 

setYDimensionOfPerceivedObject()

void etsi_its_cpm_ts_msgs::access::setYDimensionOfPerceivedObject ( PerceivedObject & object, const double value, const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE )

inline

Sets the y-dimension of a perceived object.

This function sets the y-dimension of the given PerceivedObject to the specified value. The y-dimension usually represents the width of the object.

Parameters

object	The PerceivedObject to modify.
value	The value to set as the y-dimension in meters.
confidence	The confidence of the y-dimension value in meters (optional, default is ObjectDimensionConfidence::UNAVAILABLE).

Definition at line 592 of file cpm_ts_setters.h.

                                     {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v2-1-1_setters.h>
 
inline void setItsPduHeader(CollectivePerceptionMessage& cpm, const uint32_t station_id,
                            const uint8_t protocol_version = 0) {
  setItsPduHeader(cpm.header, MessageId::CPM, station_id, protocol_version);
}
 
inline void setReferenceTime(
    CollectivePerceptionMessage& cpm, const uint64_t unix_nanosecs,
    const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.end()->second) {
  TimestampIts t_its;
  setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
  throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
  cpm.payload.management_container.reference_time = t_its;
}
 
inline void setReferencePosition(CollectivePerceptionMessage& cpm, const double latitude, const double longitude,
                                 const double altitude = AltitudeValue::UNAVAILABLE) {
  setReferencePosition(cpm.payload.management_container.reference_position, latitude, longitude, altitude);
}
 
inline void setFromUTMPosition(CollectivePerceptionMessage& cpm, const gm::PointStamped& utm_position, const int& zone,
                               const bool& northp) {
  setFromUTMPosition(cpm.payload.management_container.reference_position, utm_position, zone, northp);
}
 
inline void setIdOfPerceivedObject(PerceivedObject& object, const uint16_t id) {
  object.object_id.value = id;
  object.object_id_is_present = true;
}
 
inline void setMeasurementDeltaTimeOfPerceivedObject(PerceivedObject& object, const int16_t delta_time = 0) {
  if (delta_time < DeltaTimeMilliSecondSigned::MIN || delta_time > DeltaTimeMilliSecondSigned::MAX) {
    throw std::invalid_argument("MeasurementDeltaTime out of range");
  } else {
    object.measurement_delta_time.value = delta_time;
  }
}
 
inline void setCartesianCoordinateWithConfidence(CartesianCoordinateWithConfidence& coordinate, const int32_t value,
                                                 const uint16_t confidence = CoordinateConfidence::UNAVAILABLE) {
  // limit value range
  if (value < CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE;
  } else if (value > CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE;
  } else {
    coordinate.value.value = value;
  }
 
  // limit confidence range
  if (confidence > CoordinateConfidence::MAX || confidence < CoordinateConfidence::MIN) {
    coordinate.confidence.value = CoordinateConfidence::OUT_OF_RANGE;
  } else {
    coordinate.confidence.value = confidence;
  }
}
 
inline void setPositionOfPerceivedObject(PerceivedObject& object, const gm::Point& point,
                                         const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  setCartesianCoordinateWithConfidence(object.position.x_coordinate, point.x * 100, x_confidence * 100);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate, point.y * 100, y_confidence * 100);
  if (point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate, point.z * 100, z_confidence * 100);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setUTMPositionOfPerceivedObject(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                            const gm::PointStamped& utm_position,
                                            const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  gm::PointStamped reference_position = getUTMPosition(cpm);
  if (utm_position.header.frame_id != reference_position.header.frame_id) {
    throw std::invalid_argument("UTM-Position frame_id (" + utm_position.header.frame_id +
                                ") does not match the reference position frame_id (" + reference_position.header.frame_id +
                                ")");
  }
  setCartesianCoordinateWithConfidence(object.position.x_coordinate,
                                       (utm_position.point.x - reference_position.point.x) * 100, x_confidence);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate,
                                       (utm_position.point.y - reference_position.point.y) * 100, y_confidence);
  if (utm_position.point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate,
                                         (utm_position.point.z - reference_position.point.z) * 100, z_confidence);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setVelocityComponent(VelocityComponent& velocity, const int16_t value,
                                 const uint8_t confidence = SpeedConfidence::UNAVAILABLE) {
  // limit value range
  if (value < VelocityComponentValue::NEGATIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > VelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::POSITIVE_OUT_OF_RANGE;
  } else {
    velocity.value.value = value;
  }
 
  // limit confidence range
  if (confidence > SpeedConfidence::MAX || confidence < SpeedConfidence::MIN) {
    velocity.confidence.value = SpeedConfidence::OUT_OF_RANGE;
  } else {
    velocity.confidence.value = confidence;
  }
}
 
inline void setVelocityOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_velocity,
                                         const uint8_t x_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t y_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t z_confidence = SpeedConfidence::UNAVAILABLE) {
  object.velocity.choice = Velocity3dWithConfidence::CHOICE_CARTESIAN_VELOCITY;
  setVelocityComponent(object.velocity.cartesian_velocity.x_velocity, cartesian_velocity.x * 100, x_confidence * 100);
  setVelocityComponent(object.velocity.cartesian_velocity.y_velocity, cartesian_velocity.y * 100, y_confidence * 100);
  if (cartesian_velocity.z != 0.0) {
    setVelocityComponent(object.velocity.cartesian_velocity.z_velocity, cartesian_velocity.z * 100, z_confidence * 100);
    object.velocity.cartesian_velocity.z_velocity_is_present = true;
  }
  object.velocity_is_present = true;
}
 
inline void setAccelerationComponent(AccelerationComponent& acceleration, const int16_t value,
                                     const uint8_t confidence = AccelerationConfidence::UNAVAILABLE) {
  // limit value range
  if (value < AccelerationValue::NEGATIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > AccelerationValue::POSITIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::POSITIVE_OUT_OF_RANGE;
  } else {
    acceleration.value.value = value;
  }
 
  // limit confidence range
  if (confidence > AccelerationConfidence::MAX || confidence < AccelerationConfidence::MIN) {
    acceleration.confidence.value = AccelerationConfidence::OUT_OF_RANGE;
  } else {
    acceleration.confidence.value = confidence;
  }
}
 
inline void setAccelerationOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_acceleration,
                                             const uint8_t x_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t y_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t z_confidence = AccelerationConfidence::UNAVAILABLE) {
  object.acceleration.choice = Acceleration3dWithConfidence::CHOICE_CARTESIAN_ACCELERATION;
  setAccelerationComponent(object.acceleration.cartesian_acceleration.x_acceleration, cartesian_acceleration.x * 10,
                           x_confidence * 10);
  setAccelerationComponent(object.acceleration.cartesian_acceleration.y_acceleration, cartesian_acceleration.y * 10,
                           y_confidence * 10);
  if (cartesian_acceleration.z != 0.0) {
    setAccelerationComponent(object.acceleration.cartesian_acceleration.z_acceleration, cartesian_acceleration.z * 10,
                             z_confidence * 10);
    object.acceleration.cartesian_acceleration.z_acceleration_is_present = true;
  }
  object.acceleration_is_present = true;
}
 
inline void setYawOfPerceivedObject(PerceivedObject& object, const double yaw,
                                    const uint8_t confidence = AngleConfidence::UNAVAILABLE) {
  // wrap angle to range [0, 360]
  double yaw_in_degrees = yaw * 180 / M_PI + 180;  // TODO: check if this is correct
  while (yaw_in_degrees > 360.0) yaw_in_degrees -= 360.0;
  while (yaw_in_degrees < 0) yaw_in_degrees += 360.0;
  object.angles.z_angle.value.value = yaw_in_degrees * 10;
 
  if (confidence > AngleConfidence::MAX || confidence < AngleConfidence::MIN) {
    object.angles.z_angle.confidence.value = AngleConfidence::OUT_OF_RANGE;
  } else {
    object.angles.z_angle.confidence.value = confidence;
  }
  object.angles_is_present = true;
}
 
inline void setYawRateOfPerceivedObject(PerceivedObject& object, const double yaw_rate,
                                        const uint8_t confidence = AngularSpeedConfidence::UNAVAILABLE) {
  int16_t yaw_rate_in_degrees = yaw_rate * 180 / M_PI;
  if (yaw_rate_in_degrees != CartesianAngularVelocityComponentValue::UNAVAILABLE) {
    // limit value range
    if (yaw_rate_in_degrees < CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE;
    } else if (yaw_rate_in_degrees > CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE;
    }
  }
  object.z_angular_velocity.value.value = yaw_rate_in_degrees;
  object.z_angular_velocity.confidence.value = confidence;
  object.z_angular_velocity_is_present = true;
}
 
inline void setObjectDimension(ObjectDimension& dimension, const uint16_t value,
                               const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  // limit value range
  if (value < ObjectDimensionValue::MIN || value > ObjectDimensionValue::MAX) {
    dimension.value.value = ObjectDimensionValue::OUT_OF_RANGE;
  } else {
    dimension.value.value = value;
  }
 
  // limit confidence range
  if (confidence > ObjectDimensionConfidence::MAX || confidence < ObjectDimensionConfidence::MIN) {
    dimension.confidence.value = ObjectDimensionConfidence::OUT_OF_RANGE;
  } else {
    dimension.confidence.value = confidence;
  }
}
 
inline void setXDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_x, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_x_is_present = true;
}
 
inline void setYDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_y, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_y_is_present = true;
}
 
inline void setZDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_z, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_z_is_present = true;
}
 
inline void setDimensionsOfPerceivedObject(PerceivedObject& object, const gm::Vector3& dimensions,
                                           const uint8_t x_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t y_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t z_confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setXDimensionOfPerceivedObject(object, dimensions.x, x_confidence);
  setYDimensionOfPerceivedObject(object, dimensions.y, y_confidence);
  setZDimensionOfPerceivedObject(object, dimensions.z, z_confidence);
}
 
inline void initPerceivedObject(PerceivedObject& object, const gm::Point& point, const int16_t delta_time = 0) {
  setPositionOfPerceivedObject(object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectWithUTMPosition(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                               const gm::PointStamped& point, const int16_t delta_time = 0) {
  setUTMPositionOfPerceivedObject(cpm, object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectContainer(WrappedCpmContainer& container, const uint8_t n_objects = 0) {
  container.container_id.value = CpmContainerId::PERCEIVED_OBJECT_CONTAINER;
  container.container_data.choice = container.container_id;
  container.container_data.perceived_object_container.number_of_perceived_objects.value = n_objects;
}
 
inline void addPerceivedObjectToContainer(WrappedCpmContainer& container, const PerceivedObject& perceived_object) {
  if (container.container_id.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER &&
      container.container_data.choice.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER) {
    container.container_data.perceived_object_container.perceived_objects.array.push_back(perceived_object);
    container.container_data.perceived_object_container.number_of_perceived_objects.value =
        container.container_data.perceived_object_container.perceived_objects.array.size();
  } else {
    throw std::invalid_argument("Container is not a PerceivedObjectContainer");
  }
}
 
inline void addContainerToCPM(CollectivePerceptionMessage& cpm, const WrappedCpmContainer& container) {
  // check for maximum number of containers
  if (cpm.payload.cpm_containers.value.array.size() < WrappedCpmContainers::MAX_SIZE) {
    cpm.payload.cpm_containers.value.array.push_back(container);
  } else {
    throw std::invalid_argument("Maximum number of CPM-Containers reached");
  }
}
 
}  // namespace etsi_its_cpm_ts_msgs::access

setZDimensionOfPerceivedObject()

void etsi_its_cpm_ts_msgs::access::setZDimensionOfPerceivedObject ( PerceivedObject & object, const double value, const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE )

inline

Sets the z-dimension of a perceived object.

This function sets the z-dimension of the given PerceivedObject to the specified value. The z-dimension usually represents the height of the object.

Parameters

object	The PerceivedObject to modify.
value	The value to set as the z-dimension in meters.
confidence	The confidence of the z-dimension value in meters (optional, default is ObjectDimensionConfidence::UNAVAILABLE).

Definition at line 608 of file cpm_ts_setters.h.

                                     {
 
#include <etsi_its_msgs_utils/impl/cdd/cdd_v2-1-1_setters.h>
 
inline void setItsPduHeader(CollectivePerceptionMessage& cpm, const uint32_t station_id,
                            const uint8_t protocol_version = 0) {
  setItsPduHeader(cpm.header, MessageId::CPM, station_id, protocol_version);
}
 
inline void setReferenceTime(
    CollectivePerceptionMessage& cpm, const uint64_t unix_nanosecs,
    const uint16_t n_leap_seconds = etsi_its_msgs::LEAP_SECOND_INSERTIONS_SINCE_2004.end()->second) {
  TimestampIts t_its;
  setTimestampITS(t_its, unix_nanosecs, n_leap_seconds);
  throwIfOutOfRange(t_its.value, TimestampIts::MIN, TimestampIts::MAX, "TimestampIts");
  cpm.payload.management_container.reference_time = t_its;
}
 
inline void setReferencePosition(CollectivePerceptionMessage& cpm, const double latitude, const double longitude,
                                 const double altitude = AltitudeValue::UNAVAILABLE) {
  setReferencePosition(cpm.payload.management_container.reference_position, latitude, longitude, altitude);
}
 
inline void setFromUTMPosition(CollectivePerceptionMessage& cpm, const gm::PointStamped& utm_position, const int& zone,
                               const bool& northp) {
  setFromUTMPosition(cpm.payload.management_container.reference_position, utm_position, zone, northp);
}
 
inline void setIdOfPerceivedObject(PerceivedObject& object, const uint16_t id) {
  object.object_id.value = id;
  object.object_id_is_present = true;
}
 
inline void setMeasurementDeltaTimeOfPerceivedObject(PerceivedObject& object, const int16_t delta_time = 0) {
  if (delta_time < DeltaTimeMilliSecondSigned::MIN || delta_time > DeltaTimeMilliSecondSigned::MAX) {
    throw std::invalid_argument("MeasurementDeltaTime out of range");
  } else {
    object.measurement_delta_time.value = delta_time;
  }
}
 
inline void setCartesianCoordinateWithConfidence(CartesianCoordinateWithConfidence& coordinate, const int32_t value,
                                                 const uint16_t confidence = CoordinateConfidence::UNAVAILABLE) {
  // limit value range
  if (value < CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::NEGATIVE_OUT_OF_RANGE;
  } else if (value > CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE) {
    coordinate.value.value = CartesianCoordinateLarge::POSITIVE_OUT_OF_RANGE;
  } else {
    coordinate.value.value = value;
  }
 
  // limit confidence range
  if (confidence > CoordinateConfidence::MAX || confidence < CoordinateConfidence::MIN) {
    coordinate.confidence.value = CoordinateConfidence::OUT_OF_RANGE;
  } else {
    coordinate.confidence.value = confidence;
  }
}
 
inline void setPositionOfPerceivedObject(PerceivedObject& object, const gm::Point& point,
                                         const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                         const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  setCartesianCoordinateWithConfidence(object.position.x_coordinate, point.x * 100, x_confidence * 100);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate, point.y * 100, y_confidence * 100);
  if (point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate, point.z * 100, z_confidence * 100);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setUTMPositionOfPerceivedObject(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                            const gm::PointStamped& utm_position,
                                            const uint16_t x_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t y_confidence = CoordinateConfidence::UNAVAILABLE,
                                            const uint16_t z_confidence = CoordinateConfidence::UNAVAILABLE) {
  gm::PointStamped reference_position = getUTMPosition(cpm);
  if (utm_position.header.frame_id != reference_position.header.frame_id) {
    throw std::invalid_argument("UTM-Position frame_id (" + utm_position.header.frame_id +
                                ") does not match the reference position frame_id (" + reference_position.header.frame_id +
                                ")");
  }
  setCartesianCoordinateWithConfidence(object.position.x_coordinate,
                                       (utm_position.point.x - reference_position.point.x) * 100, x_confidence);
  setCartesianCoordinateWithConfidence(object.position.y_coordinate,
                                       (utm_position.point.y - reference_position.point.y) * 100, y_confidence);
  if (utm_position.point.z != 0.0) {
    setCartesianCoordinateWithConfidence(object.position.z_coordinate,
                                         (utm_position.point.z - reference_position.point.z) * 100, z_confidence);
    object.position.z_coordinate_is_present = true;
  }
}
 
inline void setVelocityComponent(VelocityComponent& velocity, const int16_t value,
                                 const uint8_t confidence = SpeedConfidence::UNAVAILABLE) {
  // limit value range
  if (value < VelocityComponentValue::NEGATIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > VelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
    velocity.value.value = VelocityComponentValue::POSITIVE_OUT_OF_RANGE;
  } else {
    velocity.value.value = value;
  }
 
  // limit confidence range
  if (confidence > SpeedConfidence::MAX || confidence < SpeedConfidence::MIN) {
    velocity.confidence.value = SpeedConfidence::OUT_OF_RANGE;
  } else {
    velocity.confidence.value = confidence;
  }
}
 
inline void setVelocityOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_velocity,
                                         const uint8_t x_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t y_confidence = SpeedConfidence::UNAVAILABLE,
                                         const uint8_t z_confidence = SpeedConfidence::UNAVAILABLE) {
  object.velocity.choice = Velocity3dWithConfidence::CHOICE_CARTESIAN_VELOCITY;
  setVelocityComponent(object.velocity.cartesian_velocity.x_velocity, cartesian_velocity.x * 100, x_confidence * 100);
  setVelocityComponent(object.velocity.cartesian_velocity.y_velocity, cartesian_velocity.y * 100, y_confidence * 100);
  if (cartesian_velocity.z != 0.0) {
    setVelocityComponent(object.velocity.cartesian_velocity.z_velocity, cartesian_velocity.z * 100, z_confidence * 100);
    object.velocity.cartesian_velocity.z_velocity_is_present = true;
  }
  object.velocity_is_present = true;
}
 
inline void setAccelerationComponent(AccelerationComponent& acceleration, const int16_t value,
                                     const uint8_t confidence = AccelerationConfidence::UNAVAILABLE) {
  // limit value range
  if (value < AccelerationValue::NEGATIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::NEGATIVE_OUT_OF_RANGE;
  } else if (value > AccelerationValue::POSITIVE_OUT_OF_RANGE) {
    acceleration.value.value = AccelerationValue::POSITIVE_OUT_OF_RANGE;
  } else {
    acceleration.value.value = value;
  }
 
  // limit confidence range
  if (confidence > AccelerationConfidence::MAX || confidence < AccelerationConfidence::MIN) {
    acceleration.confidence.value = AccelerationConfidence::OUT_OF_RANGE;
  } else {
    acceleration.confidence.value = confidence;
  }
}
 
inline void setAccelerationOfPerceivedObject(PerceivedObject& object, const gm::Vector3& cartesian_acceleration,
                                             const uint8_t x_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t y_confidence = AccelerationConfidence::UNAVAILABLE,
                                             const uint8_t z_confidence = AccelerationConfidence::UNAVAILABLE) {
  object.acceleration.choice = Acceleration3dWithConfidence::CHOICE_CARTESIAN_ACCELERATION;
  setAccelerationComponent(object.acceleration.cartesian_acceleration.x_acceleration, cartesian_acceleration.x * 10,
                           x_confidence * 10);
  setAccelerationComponent(object.acceleration.cartesian_acceleration.y_acceleration, cartesian_acceleration.y * 10,
                           y_confidence * 10);
  if (cartesian_acceleration.z != 0.0) {
    setAccelerationComponent(object.acceleration.cartesian_acceleration.z_acceleration, cartesian_acceleration.z * 10,
                             z_confidence * 10);
    object.acceleration.cartesian_acceleration.z_acceleration_is_present = true;
  }
  object.acceleration_is_present = true;
}
 
inline void setYawOfPerceivedObject(PerceivedObject& object, const double yaw,
                                    const uint8_t confidence = AngleConfidence::UNAVAILABLE) {
  // wrap angle to range [0, 360]
  double yaw_in_degrees = yaw * 180 / M_PI + 180;  // TODO: check if this is correct
  while (yaw_in_degrees > 360.0) yaw_in_degrees -= 360.0;
  while (yaw_in_degrees < 0) yaw_in_degrees += 360.0;
  object.angles.z_angle.value.value = yaw_in_degrees * 10;
 
  if (confidence > AngleConfidence::MAX || confidence < AngleConfidence::MIN) {
    object.angles.z_angle.confidence.value = AngleConfidence::OUT_OF_RANGE;
  } else {
    object.angles.z_angle.confidence.value = confidence;
  }
  object.angles_is_present = true;
}
 
inline void setYawRateOfPerceivedObject(PerceivedObject& object, const double yaw_rate,
                                        const uint8_t confidence = AngularSpeedConfidence::UNAVAILABLE) {
  int16_t yaw_rate_in_degrees = yaw_rate * 180 / M_PI;
  if (yaw_rate_in_degrees != CartesianAngularVelocityComponentValue::UNAVAILABLE) {
    // limit value range
    if (yaw_rate_in_degrees < CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::NEGATIVE_OUTOF_RANGE;
    } else if (yaw_rate_in_degrees > CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE) {
      yaw_rate_in_degrees = CartesianAngularVelocityComponentValue::POSITIVE_OUT_OF_RANGE;
    }
  }
  object.z_angular_velocity.value.value = yaw_rate_in_degrees;
  object.z_angular_velocity.confidence.value = confidence;
  object.z_angular_velocity_is_present = true;
}
 
inline void setObjectDimension(ObjectDimension& dimension, const uint16_t value,
                               const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  // limit value range
  if (value < ObjectDimensionValue::MIN || value > ObjectDimensionValue::MAX) {
    dimension.value.value = ObjectDimensionValue::OUT_OF_RANGE;
  } else {
    dimension.value.value = value;
  }
 
  // limit confidence range
  if (confidence > ObjectDimensionConfidence::MAX || confidence < ObjectDimensionConfidence::MIN) {
    dimension.confidence.value = ObjectDimensionConfidence::OUT_OF_RANGE;
  } else {
    dimension.confidence.value = confidence;
  }
}
 
inline void setXDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_x, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_x_is_present = true;
}
 
inline void setYDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_y, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_y_is_present = true;
}
 
inline void setZDimensionOfPerceivedObject(PerceivedObject& object, const double value,
                                           const uint8_t confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setObjectDimension(object.object_dimension_z, (uint16_t)(value * 10), confidence * 10);
  object.object_dimension_z_is_present = true;
}
 
inline void setDimensionsOfPerceivedObject(PerceivedObject& object, const gm::Vector3& dimensions,
                                           const uint8_t x_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t y_confidence = ObjectDimensionConfidence::UNAVAILABLE,
                                           const uint8_t z_confidence = ObjectDimensionConfidence::UNAVAILABLE) {
  setXDimensionOfPerceivedObject(object, dimensions.x, x_confidence);
  setYDimensionOfPerceivedObject(object, dimensions.y, y_confidence);
  setZDimensionOfPerceivedObject(object, dimensions.z, z_confidence);
}
 
inline void initPerceivedObject(PerceivedObject& object, const gm::Point& point, const int16_t delta_time = 0) {
  setPositionOfPerceivedObject(object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectWithUTMPosition(CollectivePerceptionMessage& cpm, PerceivedObject& object,
                                               const gm::PointStamped& point, const int16_t delta_time = 0) {
  setUTMPositionOfPerceivedObject(cpm, object, point);
  setMeasurementDeltaTimeOfPerceivedObject(object, delta_time);
}
 
inline void initPerceivedObjectContainer(WrappedCpmContainer& container, const uint8_t n_objects = 0) {
  container.container_id.value = CpmContainerId::PERCEIVED_OBJECT_CONTAINER;
  container.container_data.choice = container.container_id;
  container.container_data.perceived_object_container.number_of_perceived_objects.value = n_objects;
}
 
inline void addPerceivedObjectToContainer(WrappedCpmContainer& container, const PerceivedObject& perceived_object) {
  if (container.container_id.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER &&
      container.container_data.choice.value == CpmContainerId::PERCEIVED_OBJECT_CONTAINER) {
    container.container_data.perceived_object_container.perceived_objects.array.push_back(perceived_object);
    container.container_data.perceived_object_container.number_of_perceived_objects.value =
        container.container_data.perceived_object_container.perceived_objects.array.size();
  } else {
    throw std::invalid_argument("Container is not a PerceivedObjectContainer");
  }
}
 
inline void addContainerToCPM(CollectivePerceptionMessage& cpm, const WrappedCpmContainer& container) {
  // check for maximum number of containers
  if (cpm.payload.cpm_containers.value.array.size() < WrappedCpmContainers::MAX_SIZE) {
    cpm.payload.cpm_containers.value.array.push_back(container);
  } else {
    throw std::invalid_argument("Maximum number of CPM-Containers reached");
  }
}
 
}  // namespace etsi_its_cpm_ts_msgs::access

throwIfOutOfRange()

template<typename T1 , typename T2 >

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

Definition at line 37 of file cpm_ts_access.h.