state_getters.h

Go to the documentation of this file.

// Copyright Institute for Automotive Engineering (ika), RWTH Aachen University
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <perception_msgs_utils/impl/state_index.h>
#include <perception_msgs_utils/impl/checks.h>
 
 
namespace perception_msgs {
 
namespace object_access {
  inline double getX(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexX(state.model_id)];
  }
 
 
  template <typename T>
  inline double getX(const T& obj) {
    return getX(obj.state);
  }
 
  inline double getY(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexY(state.model_id)];
  }
 
  template <typename T>
  inline double getY(const T& obj) {
    return getY(obj.state);
  }
 
  inline double getZ(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexZ(state.model_id)];
  }
 
  template <typename T>
  inline double getZ(const T& obj) {
    return getZ(obj.state);
  }
 
  inline double getVelLon(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexVelLon(state.model_id)];
  }
 
  template <typename T>
  inline double getVelLon(const T& obj) {
    return getVelLon(obj.state);
  }
 
  inline double getVelLat(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexVelLat(state.model_id)];
  }
 
  template <typename T>
  inline double getVelLat(const T& obj) {
    return getVelLat(obj.state);
  }
 
  inline double getAccLon(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexAccLon(state.model_id)];
  }
 
  template <typename T>
  inline double getAccLon(const T& obj) {
    return getAccLon(obj.state);
  }
 
  inline double getAccLat(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexAccLat(state.model_id)];
  }
 
  template <typename T>
  inline double getAccLat(const T& obj) {
    return getAccLat(obj.state);
  }
 
  inline double getRoll(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexRoll(state.model_id)];
  }
 
  template <typename T>
  inline double getRoll(const T& obj) {
    return getRoll(obj.state);
  }
 
  inline double getRollRate(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexRollRate(state.model_id)];
  }
 
  template <typename T>
  inline double getRollRate(const T& obj) {
    return getRollRate(obj.state);
  }
 
  inline double getPitch(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexPitch(state.model_id)];
  }
 
  template <typename T>
  inline double getPitch(const T& obj) {
    return getPitch(obj.state);
  }
 
  inline double getPitchRate(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexPitchRate(state.model_id)];
  }
 
  template <typename T>
  inline double getPitchRate(const T& obj) {
    return getPitchRate(obj.state);
  }
 
  inline double getYaw(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexYaw(state.model_id)];
  }
 
  template <typename T>
  inline double getYaw(const T& obj) {
    return getYaw(obj.state);
  }
 
  inline double getYawRate(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexYawRate(state.model_id)];
  }
 
  template <typename T>
  inline double getYawRate(const T& obj) {
    return getYawRate(obj.state);
  }
 
  inline double getSteeringAngleAck(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexSteeringAngleAck(state.model_id)];
  }
 
  template <typename T>
  inline double getSteeringAngleAck(const T& obj) {
    return getSteeringAngleAck(obj.state);
  }
 
  inline double getSteeringAngleRateAck(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexSteeringAngleRateAck(state.model_id)];
  }
 
  template <typename T>
  inline double getSteeringAngleRateAck(const T& obj) {
    return getSteeringAngleRateAck(obj.state);
  }
 
  inline double getSteeringAngleFront(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexSteeringAngleFront(state.model_id)];
  }
 
  template <typename T>
  inline double getSteeringAngleFront(const T& obj) {
    return getSteeringAngleFront(obj.state);
  }
 
  inline double getSteeringAngleRear(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexSteeringAngleRear(state.model_id)];
  }
 
  template <typename T>
  inline double getSteeringAngleRear(const T& obj) {
    return getSteeringAngleRear(obj.state);
  }
 
  inline double getWidth(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexWidth(state.model_id)];
  }
 
  template <typename T>
  inline double getWidth(const T& obj) {
    return getWidth(obj.state);
  }
 
  inline double getLength(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexLength(state.model_id)];
  }
 
  template <typename T>
  inline double getLength(const T& obj) {
    return getLength(obj.state);
  }
 
  inline double getHeight(const ObjectState& state) {
    sanityCheckContinuousState(state);
    return state.continuous_state[indexHeight(state.model_id)];
  }
 
  template <typename T>
  inline double getHeight(const T& obj) {
    return getHeight(obj.state);
  }
 
  inline bool getStandstill(const ObjectState& state) {
    sanityCheckDiscreteState(state);
    return state.discrete_state[indexStandstill(state.model_id)];
  }
 
  template <typename T>
  inline bool getStandstill(const T& obj) {
    return getStandstill(obj.state);
  }
 
  inline uint8_t getTurnIndicator(const ObjectState& state) {
    sanityCheckDiscreteState(state);
    return state.discrete_state[indexTurnIndicator(state.model_id)];
  }
 
  template <typename T>
  inline uint8_t getTurnIndicator(const T& obj) {
    return getTurnIndicator(obj.state);
  }
 
  inline uint8_t getBrakeLight(const ObjectState& state) {
    sanityCheckDiscreteState(state);
    return state.discrete_state[indexBrakeLight(state.model_id)];
  }
 
  template <typename T>
  inline uint8_t getBrakeLight(const T& obj) {
    return getBrakeLight(obj.state);
  }
 
  inline uint8_t getReverseLight(const ObjectState& state) {
    sanityCheckDiscreteState(state);
    return state.discrete_state[indexReverseLight(state.model_id)];
  }
 
  template <typename T>
  inline uint8_t getReverseLight(const T& obj) {
    return getReverseLight(obj.state);
  }
 
  inline uint8_t getTrafficLightState(const ObjectState& state) {
    sanityCheckDiscreteState(state);
    return state.discrete_state[indexTrafficLightState(state.model_id)];
  }
 
  template <typename T>
  inline uint8_t getTrafficLightState(const T& obj) {
    return getTrafficLightState(obj.state);
  }
 
  inline uint8_t getTrafficLightType(const ObjectState& state) {
    sanityCheckDiscreteState(state);
    return state.discrete_state[indexTrafficLightType(state.model_id)];
  }
 
  template <typename T>
  inline uint8_t getTrafficLightType(const T& obj) {
    return getTrafficLightType(obj.state);
  }
 
} // namespace object_access
 
} // namespace perception_msgs