Merge branch 'initializable-base-classes' into 'main'

Allow custom initialization of base classes

Closes #78

See merge request !155

include/MantleAPI/Traffic/control_strategy.h

@@ -24,6 +24,7 @@
 #include <MantleAPI/Traffic/traffic_light_properties.h>
 #include <MantleAPI/Traffic/vehicle_light_properties.h>
 
+#include <utility>  // std::move
 #include <vector>
 
 namespace mantle_api
@@ -59,12 +60,20 @@ enum class ControlStrategyType
 /// The runtime mapping of an private action instance to the simulator core.
 struct ControlStrategy
 {
+  /// @brief Constructs a ControlStrategy from its members
+  ///
+  /// @param[in] movement_domain Movement domain of the control strategy
+  /// @param[in] type            Type of the control strategy
+  explicit ControlStrategy(MovementDomain movement_domain = MovementDomain::kUndefined,
+                           ControlStrategyType type = ControlStrategyType::kUndefined)
+      : movement_domain{movement_domain}, type{type} {}
+
   virtual ~ControlStrategy() = default;
 
   // TODO: extend by bool use_dynamic_constraints when needed (false assumed at the moment)
 
-  MovementDomain movement_domain{MovementDomain::kUndefined};  ///< Movement domain of the control strategy
-  ControlStrategyType type{ControlStrategyType::kUndefined};   ///< Type of the control strategy
+  MovementDomain movement_domain;  ///< Movement domain of the control strategy
+  ControlStrategyType type;        ///< Type of the control strategy
 };
 
 /// @brief Equality comparison for ControlStrategy.
@@ -90,53 +99,61 @@ constexpr bool operator!=(const ControlStrategy& lhs, const ControlStrategy& rhs
 /// Controls an entity to keeps current velocity
 struct KeepVelocityControlStrategy : public ControlStrategy
 {
+  /// @brief Constructs a KeepVelocityControlStrategy as a ControlStrategy with predefined values
   KeepVelocityControlStrategy()
-  {
-    movement_domain = MovementDomain::kLongitudinal;
-    type = ControlStrategyType::kKeepVelocity;
-  }
+      : ControlStrategy{MovementDomain::kLongitudinal, ControlStrategyType::kKeepVelocity} {}
   // Doesn't need configuration attributes. Controller keeps current velocity on adding entity or update
 };
 
 /// Controls an entity to keeps current lane offset
 struct KeepLaneOffsetControlStrategy : public ControlStrategy
 {
+  /// @brief Constructs a KeepLaneOffsetControlStrategy as a ControlStrategy with predefined values
   KeepLaneOffsetControlStrategy()
-  {
-    movement_domain = MovementDomain::kLateral;
-    type = ControlStrategyType::kKeepLaneOffset;
-  }
+      : ControlStrategy{MovementDomain::kLateral, ControlStrategyType::kKeepLaneOffset} {}
   // Doesn't need configuration attributes. Controller keeps current lane offset on adding entity or update
 };
 
 /// Controls an entity to follow a heading angle from spline
 struct FollowHeadingSplineControlStrategy : public ControlStrategy
 {
-  FollowHeadingSplineControlStrategy()
-  {
-    movement_domain = MovementDomain::kLateral;
-    type = ControlStrategyType::kFollowHeadingSpline;
-  }
+  /// @brief Constructs a FollowHeadingSplineControlStrategy
+  /// as a ControlStrategy with predefined values
+  ///
+  /// @param[in] heading_splines List of the heading angles of splines
+  /// @param[in] default_value   The default value of the heading angle
+  explicit FollowHeadingSplineControlStrategy(
+      std::vector<mantle_api::SplineSection<units::angle::radian>> heading_splines = {},
+      units::angle::radian_t default_value = {})
+      : ControlStrategy{MovementDomain::kLateral, ControlStrategyType::kFollowHeadingSpline},
+        heading_splines{std::move(heading_splines)},
+        default_value{default_value} {}
 
   /// List of the heading angles of splines
   std::vector<mantle_api::SplineSection<units::angle::radian>> heading_splines;
   /// The default value of the heading angle
-  units::angle::radian_t default_value{0};
+  units::angle::radian_t default_value;
 };
 
 /// Controls an entity to follow a velocity from spline
 struct FollowVelocitySplineControlStrategy : public ControlStrategy
 {
-  FollowVelocitySplineControlStrategy()
-  {
-    movement_domain = MovementDomain::kLongitudinal;
-    type = ControlStrategyType::kFollowVelocitySpline;
-  }
+  /// @brief Constructs a FollowVelocitySplineControlStrategy
+  /// as a ControlStrategy with predefined values
+  ///
+  /// @param[in] velocity_splines List of the velocities of splines
+  /// @param[in] default_value    The default value of the velocity
+  explicit FollowVelocitySplineControlStrategy(
+      std::vector<mantle_api::SplineSection<units::velocity::meters_per_second>> velocity_splines = {},
+      units::velocity::meters_per_second_t default_value = {})
+      : ControlStrategy{MovementDomain::kLongitudinal, ControlStrategyType::kFollowVelocitySpline},
+        velocity_splines{std::move(velocity_splines)},
+        default_value{default_value} {}
 
   /// List of the velocities of splines
   std::vector<mantle_api::SplineSection<units::velocity::meters_per_second>> velocity_splines;
   /// The default value of the velocity
-  units::velocity::meters_per_second_t default_value{0};
+  units::velocity::meters_per_second_t default_value;
 };
 
 /// @brief Equality comparison for FollowVelocitySplineControlStrategy.
@@ -164,11 +181,14 @@ constexpr bool operator!=(const FollowVelocitySplineControlStrategy& lhs,
 /// Controls an entity to follow a lateral offset from spline
 struct FollowLateralOffsetSplineControlStrategy : public ControlStrategy
 {
-  FollowLateralOffsetSplineControlStrategy()
-  {
-    movement_domain = MovementDomain::kLateral;
-    type = ControlStrategyType::kFollowLateralOffsetSpline;
-  }
+  /// @brief Constructs a FollowLateralOffsetSplineControlStrategy
+  /// as a ControlStrategy with predefined values
+  ///
+  /// @param[in] lateral_offset_splines List of the lateral offsets of splines
+  explicit FollowLateralOffsetSplineControlStrategy(
+      std::vector<mantle_api::SplineSection<units::length::meter>> lateral_offset_splines = {})
+      : ControlStrategy{MovementDomain::kLateral, ControlStrategyType::kFollowLateralOffsetSpline},
+        lateral_offset_splines{std::move(lateral_offset_splines)} {}
 
   /// List of the lateral offsets of splines
   std::vector<mantle_api::SplineSection<units::length::meter>> lateral_offset_splines;
@@ -207,14 +227,19 @@ struct TransitionDynamics
 /// Controls the transition to a defined lane offset of an entity
 struct AcquireLaneOffsetControlStrategy : public ControlStrategy
 {
-  AcquireLaneOffsetControlStrategy()
-  {
-    movement_domain = MovementDomain::kLateral;
-    type = ControlStrategyType::kAcquireLaneOffset;
-  }
+  /// @brief Constructs a AcquireLaneOffsetControlStrategy
+  /// as a ControlStrategy with predefined values
+  ///
+  /// @param[in] offset               Lane offset
+  /// @param[in] transition_dynamics  Specifies the dynamics of a value transition
+  explicit AcquireLaneOffsetControlStrategy(units::length::meter_t offset = {},
+                                            TransitionDynamics transition_dynamics = {})
+      : ControlStrategy{MovementDomain::kLateral, ControlStrategyType::kAcquireLaneOffset},
+        offset{offset},
+        transition_dynamics{transition_dynamics} {}
 
   /// Lane offset
-  units::length::meter_t offset{};
+  units::length::meter_t offset;
   /// Specifies the dynamics of a value transition
   TransitionDynamics transition_dynamics;
 };
@@ -235,16 +260,21 @@ struct VehicleLightStatesControlStrategy : public ControlStrategy
 /// Controls the transition of a current light state to the target light state
 struct TrafficLightStateControlStrategy : public ControlStrategy
 {
-  TrafficLightStateControlStrategy()
-  {
-    type = ControlStrategyType::kUpdateTrafficLightStates;
-    movement_domain = MovementDomain::kNone;
-  }
+  /// @brief Constructs a TrafficLightStateControlStrategy
+  /// as a ControlStrategy with predefined values
+  ///
+  /// @param[in] traffic_light_phases List of specific traffic light phases
+  /// @param[in] repeat_states        Whether the light state is repeated or not
+  explicit TrafficLightStateControlStrategy(std::vector<TrafficLightPhase> traffic_light_phases = {},
+                                            bool repeat_states = false)
+      : ControlStrategy{MovementDomain::kNone, ControlStrategyType::kUpdateTrafficLightStates},
+        traffic_light_phases{std::move(traffic_light_phases)},
+        repeat_states{repeat_states} {}
 
   /// List of specific traffic light phases
-  std::vector<TrafficLightPhase> traffic_light_phases{};
+  std::vector<TrafficLightPhase> traffic_light_phases;
   /// The "repeat_states" flag determines, if the light state is repeated or not
-  bool repeat_states{false};
+  bool repeat_states;
 };
 
 /// Definition of time value context as either absolute or relative
@@ -272,11 +302,15 @@ struct FollowTrajectoryControlStrategy : public ControlStrategy
     units::time::second_t offset{0.0};
   };
 
-  FollowTrajectoryControlStrategy()
-  {
-    movement_domain = MovementDomain::kBoth;
-    type = ControlStrategyType::kFollowTrajectory;
-  }
+  /// @brief Constructs a FollowTrajectoryControlStrategy as a ControlStrategy with predefined values
+  ///
+  /// @param[in] trajectory    Chain of points describing a trajectory
+  /// @param[in] timeReference Time information provided within the trajectory
+  explicit FollowTrajectoryControlStrategy(Trajectory trajectory = {},
+                                           std::optional<TrajectoryTimeReference> timeReference = std::nullopt)
+      : ControlStrategy{MovementDomain::kBoth, ControlStrategyType::kFollowTrajectory},
+        trajectory{std::move(trajectory)},
+        timeReference{timeReference} {}
 
   /// Trajectory definition
   Trajectory trajectory;
@@ -288,18 +322,25 @@ struct FollowTrajectoryControlStrategy : public ControlStrategy
 /// Describes the transition between an entity's current lane and its target lane.
 struct PerformLaneChangeControlStrategy : public ControlStrategy
 {
-  PerformLaneChangeControlStrategy()
-  {
-    movement_domain = MovementDomain::kLateral;
-    type = ControlStrategyType::kPerformLaneChange;
-  }
+  /// @brief Constructs a PerformLaneChangeControlStrategy as a ControlStrategy with predefined values
+  ///
+  /// @param[in] target_lane_id ID of the target lane the entity will change to
+  /// @param[in] target_lane_offset Lane offset to be reached at the target lane
+  /// @param[in] transition_dynamics Shape/time of lane change action
+  explicit PerformLaneChangeControlStrategy(mantle_api::LaneId target_lane_id = {},
+                                            units::length::meter_t target_lane_offset = {},
+                                            TransitionDynamics transition_dynamics = {})
+      : ControlStrategy{MovementDomain::kLateral, ControlStrategyType::kPerformLaneChange},
+        target_lane_id{target_lane_id},
+        target_lane_offset{target_lane_offset},
+        transition_dynamics{transition_dynamics} {}
 
   /// ID of the target lane the entity will change to
-  mantle_api::LaneId target_lane_id{0};
+  mantle_api::LaneId target_lane_id;
   /// Lane offset to be reached at the target lane (the action will end there)
-  units::length::meter_t target_lane_offset{0.0};
+  units::length::meter_t target_lane_offset;
   /// Shape/time of lane change action
-  TransitionDynamics transition_dynamics{};
+  TransitionDynamics transition_dynamics;
 };
 
 }  // namespace mantle_api

include/MantleAPI/Traffic/entity_properties.h

@@ -46,18 +46,36 @@ enum class EntityType
 /// Basic properties that describe scenario entities.
 struct EntityProperties
 {
+  /// @brief Constructs EntityProperties from its members
+  ///
+  /// @param[in] bounding_box The three dimensional bounding box that encloses the entity
+  /// @param[in] type         Type of the entity object (e.g. vehicle, pedestrian)
+  /// @param[in] model        Definition of the model of the entity
+  /// @param[in] properties   Additional properties as name value pairs
+  /// @param[in] mass         The mass of the entity in kg
+  explicit EntityProperties(BoundingBox bounding_box = {},
+                            EntityType type = EntityType::kOther,
+                            std::string model = {},
+                            std::map<std::string, std::string> properties = {},
+                            units::mass::kilogram_t mass = {})
+      : bounding_box{bounding_box},
+        type{type},
+        model{std::move(model)},
+        properties{std::move(properties)},
+        mass{mass} {}
+
   virtual ~EntityProperties() = default;
 
   /// The three dimensional bounding box that encloses the entity
-  BoundingBox bounding_box{Vec3<units::length::meter_t>{}, Dimension3{}};
+  BoundingBox bounding_box;
   /// Type of the entity object (e.g. vehicle, pedestrian)
-  EntityType type{EntityType::kOther};
+  EntityType type;
   /// Definition of the model of the entity
-  std::string model{};
+  std::string model;
   /// Additional properties as name value pairs
-  std::map<std::string, std::string> properties{};
+  std::map<std::string, std::string> properties;
   /// The mass of the entity in kg
-  units::mass::kilogram_t mass{};
+  units::mass::kilogram_t mass;
 };
 
 /// @brief Equality comparison for EntityProperties.

include/MantleAPI/Traffic/i_controller_config.h

 /*******************************************************************************
- * Copyright (c) 2021-2023, Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
+ * Copyright (c) 2021-2024, Bayerische Motoren Werke Aktiengesellschaft (BMW AG)
  * Copyright (c) 2024, Mercedes-Benz Tech Innovation GmbH
  *
  * This program and the accompanying materials are made
@@ -32,13 +32,28 @@ namespace mantle_api
 /// Base definition for creating a new controller for an entity
 struct IControllerConfig
 {
+  /// @brief Constructs a IControllerConfig from its members
+  ///
+  /// @param[in] name               Name of the controller. Might be ignored by the environment.
+  /// @param[in] map_query_service  Pointer to the map query service
+  /// @param[in] control_strategies List of active control strategies
+  /// @param[in] route_definition   Specifies the route behavior for the control stratgies
+  explicit IControllerConfig(std::string name = {},
+                             ILaneLocationQueryService* map_query_service = nullptr,
+                             std::vector<std::shared_ptr<mantle_api::ControlStrategy>> control_strategies = {},
+                             RouteDefinition route_definition = {})
+      : name{std::move(name)},
+        map_query_service{map_query_service},
+        control_strategies{std::move(control_strategies)},
+        route_definition{std::move(route_definition)} {}
+
   /// @brief default destructor
   virtual ~IControllerConfig() = default;
   /// @brief Name of the controller. Might be ignored by the environment.
   std::string name;
   /// Pointer to the map query service
   /// @todo: Check why map_query_service is part of the interface because it is not set from engine side but only in the environment on calling AddController()
-  ILaneLocationQueryService* map_query_service{};
+  ILaneLocationQueryService* map_query_service;
   /// List of active control strategies
   std::vector<std::shared_ptr<mantle_api::ControlStrategy>> control_strategies;
   /// Specifies the route behavior for the control stratgies