From f748a0f676bf2b513dc30d4c0bea0e1879f5dd53 Mon Sep 17 00:00:00 2001 From: fpasch <46815108+fpasch@users.noreply.github.com> Date: Fri, 16 Oct 2020 16:15:46 +0200 Subject: [PATCH] Fixes in unstructured constellation polygon creation (#87) - Add several parameters to adjust polygon calculation - Rename parameters: vehicleFrontIntermediateRatioSteps -> vehicleFrontIntermediateYawRateChangeRatioSteps vehicleBackIntermediateRatioSteps -> vehicleBackIntermediateYawRateChangeRatioSteps - code refactoring (pedestrian and vehicle calculations now use common functions) --- ad_rss/generated/CMakeLists.txt | 2 +- .../ad/rss/world/UnstructuredSettings.hpp | 88 +- ad_rss/generated/include/ad_rss/Version.hpp | 4 +- ad_rss/impl/src/unstructured/Geometry.cpp | 39 +- .../src/unstructured/TrajectoryCommon.cpp | 175 ++++ .../src/unstructured/TrajectoryCommon.hpp | 83 +- .../src/unstructured/TrajectoryPedestrian.cpp | 455 +++++----- .../src/unstructured/TrajectoryPedestrian.hpp | 73 +- .../src/unstructured/TrajectoryVehicle.cpp | 671 +++++++-------- .../src/unstructured/TrajectoryVehicle.hpp | 124 +-- .../rss/situation/SituationSnapshotTests.cpp | 138 ++- .../SituationSnapshotValidInputRangeTests.cpp | 222 +++-- .../ad/rss/situation/SituationTests.cpp | 143 +++- .../SituationValidInputRangeTests.cpp | 216 ++--- .../SituationVectorValidInputRangeTests.cpp | 72 +- .../ad/rss/situation/VehicleStateTests.cpp | 76 +- .../VehicleStateValidInputRangeTests.cpp | 182 ++-- .../ad/rss/state/RssStateSnapshotTests.cpp | 75 +- .../RssStateSnapshotValidInputRangeTests.cpp | 114 ++- .../ad/rss/world/RssDynamicsTests.cpp | 69 +- .../world/RssDynamicsValidInputRangeTests.cpp | 481 +++++++++-- .../generated/ad/rss/world/SceneTests.cpp | 145 +++- .../rss/world/SceneValidInputRangeTests.cpp | 792 +++++++++++++++--- .../world/SceneVectorValidInputRangeTests.cpp | 216 ++++- .../rss/world/UnstructuredSettingsTests.cpp | 104 ++- ...structuredSettingsValidInputRangeTests.cpp | 253 +++++- .../ad/rss/world/WorldModelTests.cpp | 227 ++++- .../world/WorldModelValidInputRangeTests.cpp | 354 ++++++-- ad_rss/impl/test/test_support/TestSupport.cpp | 21 + doc/CHANGELOG.md | 6 +- doc/ad_rss/UnstructuredConstellations.md | 13 +- 31 files changed, 4056 insertions(+), 1577 deletions(-) diff --git a/ad_rss/generated/CMakeLists.txt b/ad_rss/generated/CMakeLists.txt index 31118d04fa..03785c8b70 100644 --- a/ad_rss/generated/CMakeLists.txt +++ b/ad_rss/generated/CMakeLists.txt @@ -14,7 +14,7 @@ ## cmake_minimum_required(VERSION 3.5) -project(ad_rss VERSION 4.3.0) +project(ad_rss VERSION 4.4.0) include(GNUInstallDirs) include(CMakePackageConfigHelpers) diff --git a/ad_rss/generated/include/ad/rss/world/UnstructuredSettings.hpp b/ad_rss/generated/include/ad/rss/world/UnstructuredSettings.hpp index ca923c91d3..8a9a7bb4ba 100644 --- a/ad_rss/generated/include/ad/rss/world/UnstructuredSettings.hpp +++ b/ad_rss/generated/include/ad/rss/world/UnstructuredSettings.hpp @@ -106,11 +106,21 @@ struct UnstructuredSettings return (pedestrianTurningRadius == other.pedestrianTurningRadius) && (driveAwayMaxAngle == other.driveAwayMaxAngle) && (vehicleYawRateChange == other.vehicleYawRateChange) && (vehicleMinRadius == other.vehicleMinRadius) && (vehicleTrajectoryCalculationStep == other.vehicleTrajectoryCalculationStep) - && (vehicleFrontIntermediateRatioSteps == other.vehicleFrontIntermediateRatioSteps) - && (vehicleBackIntermediateRatioSteps == other.vehicleBackIntermediateRatioSteps) + && (vehicleFrontIntermediateYawRateChangeRatioSteps == other.vehicleFrontIntermediateYawRateChangeRatioSteps) + && (vehicleBackIntermediateYawRateChangeRatioSteps == other.vehicleBackIntermediateYawRateChangeRatioSteps) && (vehicleBrakeIntermediateAccelerationSteps == other.vehicleBrakeIntermediateAccelerationSteps) && (vehicleContinueForwardIntermediateAccelerationSteps - == other.vehicleContinueForwardIntermediateAccelerationSteps); + == other.vehicleContinueForwardIntermediateAccelerationSteps) + && (vehicleContinueForwardIntermediateYawRateChangeRatioSteps + == other.vehicleContinueForwardIntermediateYawRateChangeRatioSteps) + && (pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + == other.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps) + && (pedestrianContinueForwardIntermediateAccelerationSteps + == other.pedestrianContinueForwardIntermediateAccelerationSteps) + && (pedestrianBrakeIntermediateAccelerationSteps == other.pedestrianBrakeIntermediateAccelerationSteps) + && (pedestrianFrontIntermediateHeadingChangeRatioSteps + == other.pedestrianFrontIntermediateHeadingChangeRatioSteps) + && (pedestrianBackIntermediateHeadingChangeRatioSteps == other.pedestrianBackIntermediateHeadingChangeRatioSteps); } /** @@ -164,7 +174,7 @@ struct UnstructuredSettings * specifying the steps on one side, therefore the resulting intermedate steps are twice this value. This value is * used for the front of the trajectory set. */ - uint32_t vehicleFrontIntermediateRatioSteps{0}; + uint32_t vehicleFrontIntermediateYawRateChangeRatioSteps{0}; /*! * During calculation of the trajectory set, multiple yaw rate ratios are used. The default is max left, max right and @@ -172,21 +182,55 @@ struct UnstructuredSettings * specifying the steps on one side, therefore the resulting intermedate steps are twice this value. This value is * used for the back of the trajectory set. */ - uint32_t vehicleBackIntermediateRatioSteps{0}; + uint32_t vehicleBackIntermediateYawRateChangeRatioSteps{0}; /*! * Specifies the intermediate acceleration steps (between brakeMax and brakeMin) used while calculating the cbrake - * trajectory set. This is applied to all vehicleResponseIntermediateAccelerationSteps, therefore it has only an - * effect if that value is >0. + * trajectory set. */ uint32_t vehicleBrakeIntermediateAccelerationSteps{0}; /*! * Specifies the intermediate acceleration steps (between brakeMin and accelMax) used while calculating the continue - * forward trajectory set. This is applied to all vehicleResponseIntermediateAccelerationSteps, therefore it has only - * an effect if that value is >0. + * forward trajectory set. */ uint32_t vehicleContinueForwardIntermediateAccelerationSteps{0}; + + /*! + * Specifies the intermediate yaw rate change ratio steps used while calculating the continue forward trajectory set. + */ + uint32_t vehicleContinueForwardIntermediateYawRateChangeRatioSteps{0}; + + /*! + * Specifies the intermediate heading change ratio steps used while calculating the continue forward trajectory set. + */ + uint32_t pedestrianContinueForwardIntermediateHeadingChangeRatioSteps{0}; + + /*! + * Specifies the intermediate steps used while calculating the continue forward trajectory set. + */ + uint32_t pedestrianContinueForwardIntermediateAccelerationSteps{0}; + + /*! + * Specifies the intermediate steps used while calculating the brake trajectory set. + */ + uint32_t pedestrianBrakeIntermediateAccelerationSteps{0}; + + /*! + * During calculation of the trajectory set, multiple heading change ratios are used. The default is max left, max + * right and no heading change. By specifying a value larger than zero more intermediate steps are used. The value is + * specifying the steps on one side, therefore the resulting intermedate steps are twice this value. This value is + * used for the front of the trajectory set. + */ + uint32_t pedestrianFrontIntermediateHeadingChangeRatioSteps{0}; + + /*! + * During calculation of the trajectory set, multiple heading change ratios are used. The default is max left, max + * right and no yaw rate change. By specifying a value larger than zero more intermediate steps are used. The value is + * specifying the steps on one side, therefore the resulting intermedate steps are twice this value. This value is + * used for the back of the trajectory set. + */ + uint32_t pedestrianBackIntermediateHeadingChangeRatioSteps{0}; }; } // namespace world @@ -238,17 +282,35 @@ inline std::ostream &operator<<(std::ostream &os, UnstructuredSettings const &_v os << "vehicleTrajectoryCalculationStep:"; os << _value.vehicleTrajectoryCalculationStep; os << ","; - os << "vehicleFrontIntermediateRatioSteps:"; - os << _value.vehicleFrontIntermediateRatioSteps; + os << "vehicleFrontIntermediateYawRateChangeRatioSteps:"; + os << _value.vehicleFrontIntermediateYawRateChangeRatioSteps; os << ","; - os << "vehicleBackIntermediateRatioSteps:"; - os << _value.vehicleBackIntermediateRatioSteps; + os << "vehicleBackIntermediateYawRateChangeRatioSteps:"; + os << _value.vehicleBackIntermediateYawRateChangeRatioSteps; os << ","; os << "vehicleBrakeIntermediateAccelerationSteps:"; os << _value.vehicleBrakeIntermediateAccelerationSteps; os << ","; os << "vehicleContinueForwardIntermediateAccelerationSteps:"; os << _value.vehicleContinueForwardIntermediateAccelerationSteps; + os << ","; + os << "vehicleContinueForwardIntermediateYawRateChangeRatioSteps:"; + os << _value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps; + os << ","; + os << "pedestrianContinueForwardIntermediateHeadingChangeRatioSteps:"; + os << _value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + os << ","; + os << "pedestrianContinueForwardIntermediateAccelerationSteps:"; + os << _value.pedestrianContinueForwardIntermediateAccelerationSteps; + os << ","; + os << "pedestrianBrakeIntermediateAccelerationSteps:"; + os << _value.pedestrianBrakeIntermediateAccelerationSteps; + os << ","; + os << "pedestrianFrontIntermediateHeadingChangeRatioSteps:"; + os << _value.pedestrianFrontIntermediateHeadingChangeRatioSteps; + os << ","; + os << "pedestrianBackIntermediateHeadingChangeRatioSteps:"; + os << _value.pedestrianBackIntermediateHeadingChangeRatioSteps; os << ")"; return os; } diff --git a/ad_rss/generated/include/ad_rss/Version.hpp b/ad_rss/generated/include/ad_rss/Version.hpp index 9238faba33..8ea9a3ab5e 100644 --- a/ad_rss/generated/include/ad_rss/Version.hpp +++ b/ad_rss/generated/include/ad_rss/Version.hpp @@ -25,7 +25,7 @@ /*! * The minor version of ad_rss */ -#define AD_RSS_VERSION_MINOR 3 +#define AD_RSS_VERSION_MINOR 4 /*! * The revision of ad_rss @@ -35,4 +35,4 @@ /*! * The version of ad_rss as string */ -#define AD_RSS_VERSION_STRING "4.3.0" +#define AD_RSS_VERSION_STRING "4.4.0" diff --git a/ad_rss/impl/src/unstructured/Geometry.cpp b/ad_rss/impl/src/unstructured/Geometry.cpp index 96f0abe29c..74d01c8941 100644 --- a/ad_rss/impl/src/unstructured/Geometry.cpp +++ b/ad_rss/impl/src/unstructured/Geometry.cpp @@ -188,9 +188,42 @@ bool combinePolygon(Polygon const &a, Polygon const &b, Polygon &result) boost::geometry::union_(a.outer(), b.outer(), unionPolygons); if (unionPolygons.size() != 1) { - spdlog::debug("Could not calculate combined polygon. Expected 1 polygon after union, found {}", - unionPolygons.size()); - return false; + auto fixed = false; + if (unionPolygons.size() == 0) + { + // if union reports zero polygons, it might happen that one polygon is covered by the other + auto aCoveredByB = true; + for (auto it = a.outer().cbegin(); (it != a.outer().cend()) && aCoveredByB; ++it) + { + aCoveredByB &= boost::geometry::covered_by(*it, b.outer()); + } + if (aCoveredByB) + { + fixed = true; + result = b; + } + if (!fixed) + { + auto bCoveredByA = true; + for (auto it = b.outer().cbegin(); (it != b.outer().cend()) && bCoveredByA; ++it) + { + bCoveredByA &= boost::geometry::covered_by(*it, a.outer()); + } + if (bCoveredByA) + { + fixed = true; + result = a; + } + } + } + if (!fixed) + { + spdlog::warn("Could not calculate combined polygon. Expected 1 polygon after union, found {}. A:\n{}\nB:\n{}", + unionPolygons.size(), + std::to_string(a), + std::to_string(b)); + return false; + } } else { diff --git a/ad_rss/impl/src/unstructured/TrajectoryCommon.cpp b/ad_rss/impl/src/unstructured/TrajectoryCommon.cpp index 7b38a3ced1..04b85afbb8 100644 --- a/ad_rss/impl/src/unstructured/TrajectoryCommon.cpp +++ b/ad_rss/impl/src/unstructured/TrajectoryCommon.cpp @@ -12,6 +12,7 @@ #include "TrajectoryCommon.hpp" #include +#include "ad/rss/unstructured/DebugDrawing.hpp" /*! * @brief namespace ad @@ -57,6 +58,180 @@ Point getVehicleCorner(TrajectoryPoint const &point, return resultPoint; } +bool calculateStepPolygon(situation::VehicleState const &vehicleState, + TrajectorySetStep const &step, + std::string const &debugNamespace, + Polygon &polygon, + TrajectorySetStepVehicleLocation &stepVehicleLocation) +{ + MultiPoint frontPtsLeft; + MultiPoint frontPtsRight; + + int idx = 0; + for (auto it = step.left.cbegin(); it != step.left.cend(); ++it) + { + auto vehicleLocationLeft = TrafficParticipantLocation(*it, vehicleState); + DEBUG_DRAWING_POLYGON(vehicleLocationLeft.toPolygon(), "blue", debugNamespace + "_left_" + std::to_string(idx)); + boost::geometry::append(frontPtsLeft, vehicleLocationLeft.toMultiPoint()); + if (it == step.left.end() - 1) + { + stepVehicleLocation.left = vehicleLocationLeft; + } + ++idx; + } + + // center + auto vehicleLocationCenter = TrafficParticipantLocation(step.center, vehicleState); + DEBUG_DRAWING_POLYGON(vehicleLocationCenter.toPolygon(), "blue", debugNamespace + "_center"); + boost::geometry::append(frontPtsLeft, vehicleLocationCenter.toMultiPoint()); + stepVehicleLocation.center = vehicleLocationCenter; + boost::geometry::append(frontPtsRight, vehicleLocationCenter.toMultiPoint()); + + idx = 0; + for (auto it = step.right.cbegin(); it != step.right.cend(); ++it) + { + auto vehicleLocationRight = TrafficParticipantLocation(*it, vehicleState); + DEBUG_DRAWING_POLYGON(vehicleLocationRight.toPolygon(), "blue", debugNamespace + "_right_" + std::to_string(idx)); + boost::geometry::append(frontPtsRight, vehicleLocationRight.toMultiPoint()); + if (it == step.right.begin()) + { + stepVehicleLocation.right = vehicleLocationRight; + } + ++idx; + } + + Polygon hullLeft; + Polygon hullRight; + boost::geometry::convex_hull(frontPtsLeft, hullLeft); + boost::geometry::convex_hull(frontPtsRight, hullRight); + auto result = combinePolygon(hullLeft, hullRight, polygon); + return result; +} + +bool calculateEstimationBetweenSteps(Polygon &polygon, + TrajectorySetStepVehicleLocation const &previousStepVehicleLocation, + TrajectorySetStepVehicleLocation const ¤tStepVehicleLocation, + std::string const &debugNamespace) +{ + // Fill potential gap between two calculation steps by using the previous and current step + if (previousStepVehicleLocation == currentStepVehicleLocation) + { + return true; + } + + Polygon hull; + MultiPoint interimPtsLeft; + boost::geometry::append(interimPtsLeft, previousStepVehicleLocation.left.toMultiPoint()); + boost::geometry::append(interimPtsLeft, previousStepVehicleLocation.center.toMultiPoint()); + boost::geometry::append(interimPtsLeft, currentStepVehicleLocation.left.toMultiPoint()); + boost::geometry::append(interimPtsLeft, currentStepVehicleLocation.center.toMultiPoint()); + Polygon hullLeft; + boost::geometry::convex_hull(interimPtsLeft, hullLeft); + + MultiPoint interimPtsRight; + boost::geometry::append(interimPtsRight, previousStepVehicleLocation.right.toMultiPoint()); + boost::geometry::append(interimPtsRight, previousStepVehicleLocation.center.toMultiPoint()); + boost::geometry::append(interimPtsRight, currentStepVehicleLocation.right.toMultiPoint()); + boost::geometry::append(interimPtsRight, currentStepVehicleLocation.center.toMultiPoint()); + Polygon hullRight; + boost::geometry::convex_hull(interimPtsRight, hullRight); + auto result = combinePolygon(hullRight, hullLeft, hull); + if (!result) + { + spdlog::debug("unstructured::calculateEstimationBetweenSteps>> Could not create estimation polygon ({})." + "left {}, right {}", + debugNamespace, + std::to_string(hullLeft), + std::to_string(hullRight)); + } + + if (result) + { + DEBUG_DRAWING_POLYGON(hull, "yellow", debugNamespace + "_hull_front"); + result = combinePolygon(polygon, hull, polygon); + if (!result) + { + spdlog::warn("unstructured::calculateEstimationBetweenSteps>> Could not combine front estimation polygon ({}) " + "with final polygon." + "polygon {}, hull {}", + debugNamespace, + std::to_string(polygon), + std::to_string(hull)); + } + } + return result; +} + +bool calculateFrontAndSidePolygon(situation::VehicleState const &vehicleState, + TrajectorySetStepVehicleLocation const &initialStepVehicleLocation, + std::vector const &sideSteps, + TrajectorySetStep const &front, + std::string const &debugNamespace, + Polygon &resultPolygon, + TrajectorySetStepVehicleLocation &frontSideStepVehicleLocation) +{ + auto result = true; + auto previousStepVehicleLocation = initialStepVehicleLocation; + //------------- + // sides + //------------- + auto idx = 0; + for (auto sideStepIt = sideSteps.cbegin(); (sideStepIt != sideSteps.cend()) && result; ++sideStepIt) + { + Polygon stepPolygon; + TrajectorySetStepVehicleLocation currentStepVehicleLocation; + result = calculateStepPolygon( + vehicleState, *sideStepIt, debugNamespace + "_" + std::to_string(idx), stepPolygon, currentStepVehicleLocation); + if (!result) + { + spdlog::debug("unstructured::calculateFrontAndSidePolygon>> Could not calculate step polygon"); + } + if (result) + { + result = calculateEstimationBetweenSteps(resultPolygon, + previousStepVehicleLocation, + currentStepVehicleLocation, + debugNamespace + "_step_estimation_" + std::to_string(idx)); + if (!result) + { + spdlog::debug("unstructured::calculateFrontAndSidePolygon>> Could not calculate between steps"); + } + previousStepVehicleLocation = currentStepVehicleLocation; + } + + if (result) + { + result = combinePolygon(resultPolygon, stepPolygon, resultPolygon); + } + idx++; + } + + //------------- + // front + //------------- + Polygon frontPolygon; + if (result) + { + result = calculateStepPolygon( + vehicleState, front, debugNamespace + "_front", frontPolygon, frontSideStepVehicleLocation); + } + if (result) + { + result = calculateEstimationBetweenSteps( + resultPolygon, previousStepVehicleLocation, frontSideStepVehicleLocation, debugNamespace + "_front_estimation"); + if (!result) + { + spdlog::debug("unstructured::calculateFrontAndSidePolygon>> Could not calculate between last step and " + "front polygon."); + } + } + if (result) + { + result = combinePolygon(resultPolygon, frontPolygon, resultPolygon); + } + return result; +} + } // namespace unstructured } // namespace rss } // namespace ad diff --git a/ad_rss/impl/src/unstructured/TrajectoryCommon.hpp b/ad_rss/impl/src/unstructured/TrajectoryCommon.hpp index 135e11dddc..91cb5407fc 100644 --- a/ad_rss/impl/src/unstructured/TrajectoryCommon.hpp +++ b/ad_rss/impl/src/unstructured/TrajectoryCommon.hpp @@ -102,6 +102,7 @@ struct TrajectorySetStep left.push_back(inLeft); right.push_back(inRight); } + std::vector left; // with positive yaw rate ratio std::vector right; // with negative yaw rate ratio TrajectoryPoint center; @@ -134,7 +135,7 @@ struct TrafficParticipantLocation backRight = getVehicleCorner(pt, vehicleState.objectState.dimension, VehicleCorner::backRight); } - Polygon toPolygon() + Polygon toPolygon() const { Polygon vehiclePolygon; boost::geometry::append(vehiclePolygon, frontRight); @@ -144,7 +145,7 @@ struct TrafficParticipantLocation boost::geometry::append(vehiclePolygon, frontRight); return vehiclePolygon; } - MultiPoint toMultiPoint() + MultiPoint toMultiPoint() const { MultiPoint geometry; boost::geometry::append(geometry, frontRight); @@ -155,6 +156,15 @@ struct TrafficParticipantLocation return geometry; } + bool operator==(TrafficParticipantLocation const &other) const + { + return (frontLeft == other.frontLeft) && (frontRight == other.frontRight) && (backLeft == other.backLeft) + && (backRight == other.backRight); + } + bool operator!=(TrafficParticipantLocation const &other) const + { + return !(*this == other); + } Point frontLeft; Point frontRight; Point backLeft; @@ -166,6 +176,75 @@ struct TrafficParticipantLocation */ using Trajectory = std::vector; +struct TrajectorySetStepVehicleLocation +{ + TrafficParticipantLocation left; + TrafficParticipantLocation right; + TrafficParticipantLocation center; + + bool operator==(TrajectorySetStepVehicleLocation const &other) const + { + return (left == other.left) && (right == other.right) && (center == other.center); + } + + bool operator!=(TrajectorySetStepVehicleLocation const &other) const + { + return !(*this == other); + } +}; + +/** + * @brief Calculate a trajectory set estimation between two steps + * + * @param[inout] polygon polygon to work on + * @param[in] previousVehicleLocation the previous possible vehicle locations + * @param[in] currentVehicleLocation the current possible vehicle locations + * @param[in] debugNamespace namespace for debugging purposes + * + * @returns false if a failure occurred during calculations, true otherwise + */ +bool calculateEstimationBetweenSteps(Polygon &polygon, + TrajectorySetStepVehicleLocation const &previousVehicleLocation, + TrajectorySetStepVehicleLocation const ¤tVehicleLocation, + std::string const &debugNamespace); +/** + * @brief Calculate a polygon for one step + * + * @param[in] vehicleState current state of the vehicle + * @param[in] step step to use for calculations + * @param[in] debugNamespace namespace for debugging purposes + * @param[out] polygon the resulting polygon + * @param[out] stepVehicleLocation vehicle locations after calculation + * + * @returns false if a failure occurred during calculations, true otherwise + */ +bool calculateStepPolygon(situation::VehicleState const &vehicleState, + TrajectorySetStep const &step, + std::string const &debugNamespace, + Polygon &polygon, + TrajectorySetStepVehicleLocation &stepVehicleLocation); + +/** + * @brief Calculate the front and side polygon + * + * @param[in] vehicleState current state of the vehicle + * @param[in] initialStepVehicleLocation the vehicle locations for the initial calculation step + * @param[in] sideSteps trajectory set steps that define the sides of the polygon + * @param[in] front trajectory set step that define the front of the polygon + * @param[in] debugNamespace namespace for debugging purposes + * @param[out] resultPolygon the resulting polygon + * @param[out] frontSideStepVehicleLocation vehicle locations of the front side + * + * @returns false if a failure occurred during calculations, true otherwise + */ +bool calculateFrontAndSidePolygon(situation::VehicleState const &vehicleState, + TrajectorySetStepVehicleLocation const &initialStepVehicleLocation, + std::vector const &sideSteps, + TrajectorySetStep const &front, + std::string const &debugNamespace, + Polygon &resultPolygon, + TrajectorySetStepVehicleLocation &frontSideStepVehicleLocation); + } // namespace unstructured } // namespace rss } // namespace ad diff --git a/ad_rss/impl/src/unstructured/TrajectoryPedestrian.cpp b/ad_rss/impl/src/unstructured/TrajectoryPedestrian.cpp index efde1bc77d..e0a933a647 100644 --- a/ad_rss/impl/src/unstructured/TrajectoryPedestrian.cpp +++ b/ad_rss/impl/src/unstructured/TrajectoryPedestrian.cpp @@ -42,6 +42,11 @@ bool TrajectoryPedestrian::calculateTrajectorySets(situation::VehicleState const vehicleState.dynamics.alphaLon.brakeMin, timeToStop); + if (DEBUG_DRAWING_IS_ENABLED()) + { + auto vehicleLocation = TrafficParticipantLocation(TrajectoryPoint(vehicleState), vehicleState); + DEBUG_DRAWING_POLYGON(vehicleLocation.toPolygon(), "black", "pedestrian_initial_position"); + } if (result) { if (vehicleState.objectState.speed == ad::physics::Speed(0.)) @@ -54,7 +59,7 @@ bool TrajectoryPedestrian::calculateTrajectorySets(situation::VehicleState const } } DEBUG_DRAWING_POLYGON(brakePolygon, "red", "pedestrian_brake"); - DEBUG_DRAWING_POLYGON(continueForwardPolygon, "green", "pedestrian_continueForward"); + DEBUG_DRAWING_POLYGON(continueForwardPolygon, "green", "pedestrian_continue_forward"); return result; } @@ -101,32 +106,28 @@ bool TrajectoryPedestrian::calculateTrajectorySetsMoving(situation::VehicleState } } - physics::Distance maxBrakeDistance = physics::Distance(0.); + physics::Distance brakeMaxDistanceAfterResponseTime = physics::Distance(0.); if (result) { - physics::Speed speed; - result = situation::calculateSpeedAndDistanceOffset(timeToStopBrakeMax, - responseTimeBackSide.center.speed, - timeToStopBrakeMax, - vehicleState.dynamics.maxSpeedOnAcceleration, - vehicleState.dynamics.alphaLon.brakeMax, - vehicleState.dynamics.alphaLon.brakeMax, - speed, - maxBrakeDistance); + physics::Speed unusedSpeed; + result = situation::calculateAcceleratedLimitedMovement(responseTimeBackSide.center.speed, + vehicleState.dynamics.maxSpeedOnAcceleration, + vehicleState.dynamics.alphaLon.brakeMax, + timeToStopBrakeMax, + unusedSpeed, + brakeMaxDistanceAfterResponseTime); } - physics::Distance minBrakeDistance = physics::Distance(0.); + physics::Distance brakeMinDistanceAfterResponseTime = physics::Distance(0.); if (result) { - physics::Speed speed; - result = situation::calculateSpeedAndDistanceOffset(timeAfterResponseTime, - responseTimeFrontSide.center.speed, - timeAfterResponseTime, - vehicleState.dynamics.maxSpeedOnAcceleration, - vehicleState.dynamics.alphaLon.brakeMin, - vehicleState.dynamics.alphaLon.brakeMin, - speed, - minBrakeDistance); + physics::Speed unusedSpeed; + result = situation::calculateAcceleratedLimitedMovement(responseTimeFrontSide.center.speed, + vehicleState.dynamics.maxSpeedOnAcceleration, + vehicleState.dynamics.alphaLon.brakeMin, + timeAfterResponseTime, + unusedSpeed, + brakeMinDistanceAfterResponseTime); if (!result) { spdlog::debug("TrajectoryPedestrian::calculateTrajectorySets>> Could not calculate speed and distance offset for " @@ -136,18 +137,16 @@ bool TrajectoryPedestrian::calculateTrajectorySetsMoving(situation::VehicleState } } - physics::Distance accelMaxDistance = physics::Distance(0.); + physics::Distance accelMaxDistanceAfterResponseTime = physics::Distance(0.); if (result) { - physics::Speed speed; - result = situation::calculateSpeedAndDistanceOffset(timeAfterResponseTime, - responseTimeFrontSide.center.speed, - timeAfterResponseTime, - vehicleState.dynamics.maxSpeedOnAcceleration, - vehicleState.dynamics.alphaLon.accelMax, - vehicleState.dynamics.alphaLon.accelMax, - speed, - accelMaxDistance); + physics::Speed unusedSpeed; + result = situation::calculateAcceleratedLimitedMovement(responseTimeFrontSide.center.speed, + vehicleState.dynamics.maxSpeedOnAcceleration, + vehicleState.dynamics.alphaLon.accelMax, + timeAfterResponseTime, + unusedSpeed, + accelMaxDistanceAfterResponseTime); if (!result) { spdlog::debug("TrajectoryPedestrian::calculateTrajectorySets>> Could not calculate speed and distance offset for " @@ -157,123 +156,165 @@ bool TrajectoryPedestrian::calculateTrajectorySetsMoving(situation::VehicleState } } - auto finalRightMinBrakeDistance = calculateFinalPoint(responseTimeFrontSide.right.front(), minBrakeDistance); - auto finalLeftMinBrakeDistance = calculateFinalPoint(responseTimeFrontSide.left.back(), minBrakeDistance); - auto finalRightMaxBrakeDistance = calculateFinalPoint(responseTimeBackSide.right.front(), maxBrakeDistance); - auto finalLeftMaxBrakeDistance = calculateFinalPoint(responseTimeBackSide.left.back(), maxBrakeDistance); //======================= // calculate brakePolygon //======================= //------------- // brake front //------------- - if (result) - { - result = calculateStepPolygon( - vehicleState, minBrakeDistance, responseTimeFrontSide, "pedestrian_brake_front", brakePolygon); - if (!result) - { - spdlog::debug("TrajectoryPedestrian::calculateTrajectorySets>> Could not calculate brake max step polygon."); - } - } + TrajectorySetStep brakeFront; + calculateTrajectoryPointsStraight(brakeMinDistanceAfterResponseTime, responseTimeFrontSide, brakeFront); //------------- // brake sides //------------- - Polygon brakeMaxBrakeMinLeftSidePolygon; - Polygon brakeMaxBrakeMinRightSidePolygon; - if (result) - { - brakeMaxBrakeMinLeftSidePolygon - = calculateSidePolygon(vehicleState, finalLeftMaxBrakeDistance, finalLeftMinBrakeDistance); - result = combinePolygon(brakeMaxBrakeMinLeftSidePolygon, brakePolygon, brakePolygon); - } - if (result) + std::vector brakeSideSteps; + physics::Speed unusedSpeed; + physics::Distance accelMaxDistanceAtResponseTime; + result = situation::calculateAcceleratedLimitedMovement(vehicleState.objectState.speed, + vehicleState.dynamics.maxSpeedOnAcceleration, + vehicleState.dynamics.alphaLon.accelMax, + vehicleState.dynamics.responseTime, + unusedSpeed, + accelMaxDistanceAtResponseTime); + auto stepWidth = accelMaxDistanceAtResponseTime + / (1 + vehicleState.dynamics.unstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps); + for (auto distance = stepWidth; distance < accelMaxDistanceAtResponseTime; distance += stepWidth) { - brakeMaxBrakeMinRightSidePolygon - = calculateSidePolygon(vehicleState, finalRightMaxBrakeDistance, finalRightMinBrakeDistance); - result = combinePolygon(brakeMaxBrakeMinRightSidePolygon, brakePolygon, brakePolygon); + auto left = TrajectoryPoint(vehicleState); + auto right = left; + auto center = left; + calculateTrajectoryPoint(left, vehicleState.dynamics, distance, physics::RatioValue(1.0)); + calculateTrajectoryPoint(right, vehicleState.dynamics, distance, physics::RatioValue(-1.0)); + calculateTrajectoryPoint(center, vehicleState.dynamics, distance, physics::RatioValue(0.0)); + TrajectorySetStep step; + step.left.push_back(left); + step.right.push_back(right); + step.center = center; + brakeSideSteps.push_back(step); } //------------- // brake back //------------- - Polygon maxBrakePolygon; + TrajectorySetStepVehicleLocation brakeMaxStepVehicleLocation; if (result) { + TrajectoryPoint finalRightMaxBrakeDistance; + calculateTrajectoryPointStraight( + responseTimeBackSide.right.front(), brakeMaxDistanceAfterResponseTime, finalRightMaxBrakeDistance); + TrajectoryPoint finalLeftMaxBrakeDistance; + calculateTrajectoryPointStraight( + responseTimeBackSide.left.back(), brakeMaxDistanceAfterResponseTime, finalLeftMaxBrakeDistance); + + auto finalRightMaxBrakeDistanceLocation = TrafficParticipantLocation(finalRightMaxBrakeDistance, vehicleState); + auto finalLeftMaxBrakeDistanceLocation = TrafficParticipantLocation(finalLeftMaxBrakeDistance, vehicleState); + + TrajectoryPoint finalCenterMaxBrakeDistance; + calculateTrajectoryPointStraight( + responseTimeBackSide.center, brakeMaxDistanceAfterResponseTime, finalCenterMaxBrakeDistance); + brakeMaxStepVehicleLocation.center = TrafficParticipantLocation(finalCenterMaxBrakeDistance, vehicleState); + brakeMaxStepVehicleLocation.left = finalLeftMaxBrakeDistanceLocation; + brakeMaxStepVehicleLocation.right = finalRightMaxBrakeDistanceLocation; + MultiPoint back; - boost::geometry::append( - back, getVehicleCorner(finalRightMaxBrakeDistance, vehicleState.objectState.dimension, VehicleCorner::backRight)); - boost::geometry::append( - back, - getVehicleCorner(finalRightMaxBrakeDistance, vehicleState.objectState.dimension, VehicleCorner::frontRight)); - boost::geometry::append( - back, getVehicleCorner(finalLeftMaxBrakeDistance, vehicleState.objectState.dimension, VehicleCorner::backLeft)); - boost::geometry::append( - back, getVehicleCorner(finalLeftMaxBrakeDistance, vehicleState.objectState.dimension, VehicleCorner::frontLeft)); - boost::geometry::convex_hull(back, maxBrakePolygon); - DEBUG_DRAWING_POLYGON(maxBrakePolygon, "red", "pedestrian_brake_back"); - combinePolygon(maxBrakePolygon, brakePolygon, brakePolygon); + boost::geometry::append(back, finalRightMaxBrakeDistanceLocation.backRight); + boost::geometry::append(back, finalRightMaxBrakeDistanceLocation.frontRight); + boost::geometry::append(back, finalLeftMaxBrakeDistanceLocation.backLeft); + boost::geometry::append(back, finalLeftMaxBrakeDistanceLocation.frontLeft); + boost::geometry::convex_hull(back, brakePolygon); + } + + if (result) + { + TrajectorySetStepVehicleLocation unusedStepVehicleLocation; + result = calculateFrontAndSidePolygon(vehicleState, + brakeMaxStepVehicleLocation, + brakeSideSteps, + brakeFront, + "pedestrian_brake", + brakePolygon, + unusedStepVehicleLocation); + if (!result) + { + spdlog::debug("TrajectoryPedestrian::calculateTrajectorySets>> Could not calculate continueForward polygon."); + } } //================================= // calculate continueForwardPolygon //================================= + continueForwardPolygon = brakePolygon; //------------- // continueForward front //------------- + TrajectorySetStep continueForwardFront; if (result) { - result = calculateStepPolygon(vehicleState, - accelMaxDistance, - responseTimeFrontSide, - "pedestrian_continueForward_front", - continueForwardPolygon); - if (!result) + calculateTrajectoryPointsStraight(accelMaxDistanceAfterResponseTime, responseTimeFrontSide, continueForwardFront); + + // max left + auto ratioDiff = physics::RatioValue( + 2.0 + / (2.0 * vehicleState.dynamics.unstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + + 2.0)); + for (auto ratioValue = ratioDiff; ratioValue <= physics::RatioValue(1.0); ratioValue += ratioDiff) { - spdlog::debug( - "TrajectoryPedestrian::calculateTrajectorySets>> Could not calculate continueForward front polygon."); + auto pt = responseTimeFrontSide.left.back(); + calculateTrajectoryPoint(pt, vehicleState.dynamics, accelMaxDistanceAfterResponseTime, ratioValue); + continueForwardFront.left.push_back(pt); } + + // max right + std::vector right; + for (auto ratioValue = physics::RatioValue(-1.0); (ratioValue < physics::RatioValue(0.0)); ratioValue += ratioDiff) + { + auto pt = responseTimeFrontSide.right.front(); + calculateTrajectoryPoint(pt, vehicleState.dynamics, accelMaxDistanceAfterResponseTime, ratioValue); + continueForwardFront.right.push_back(pt); + } + auto previousRight = std::move(continueForwardFront.right); + continueForwardFront.right = right; + continueForwardFront.right.insert(continueForwardFront.right.end(), previousRight.begin(), previousRight.end()); } //------------- // continueForward sides //------------- + std::vector continueForwardSideSteps; if (result) { - auto accelMaxLeftSidePolygon - = calculateSidePolygon(vehicleState, - finalLeftMinBrakeDistance, - calculateFinalPoint(responseTimeFrontSide.left.back(), accelMaxDistance)); - result = combinePolygon(accelMaxLeftSidePolygon, continueForwardPolygon, continueForwardPolygon); - } - if (result) - { - auto accelMaxRightSidePolygon - = calculateSidePolygon(vehicleState, - finalRightMinBrakeDistance, - calculateFinalPoint(responseTimeFrontSide.right.front(), accelMaxDistance)); - result = combinePolygon(accelMaxRightSidePolygon, continueForwardPolygon, continueForwardPolygon); - } - if (result) - { - result = combinePolygon(brakeMaxBrakeMinLeftSidePolygon, continueForwardPolygon, continueForwardPolygon); - } - if (result) - { - result = combinePolygon(brakeMaxBrakeMinRightSidePolygon, continueForwardPolygon, continueForwardPolygon); + stepWidth = (accelMaxDistanceAfterResponseTime - brakeMaxDistanceAfterResponseTime) + / (1 + vehicleState.dynamics.unstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps); + for (auto distance = brakeMaxDistanceAfterResponseTime; distance <= accelMaxDistanceAfterResponseTime; + distance += stepWidth) + { + auto left = responseTimeFrontSide.left.back(); + auto right = responseTimeFrontSide.right.front(); + auto center = responseTimeFrontSide.center; + calculateTrajectoryPoint(left, vehicleState.dynamics, distance, physics::RatioValue(1.0)); + calculateTrajectoryPoint(right, vehicleState.dynamics, distance, physics::RatioValue(-1.0)); + calculateTrajectoryPoint(center, vehicleState.dynamics, distance, physics::RatioValue(0.0)); + TrajectorySetStep step; + step.left.push_back(left); + step.right.push_back(right); + step.center = center; + continueForwardSideSteps.push_back(step); + } } - - //--------------------- - // continueForward back - //--------------------- if (result) { - combinePolygon(maxBrakePolygon, continueForwardPolygon, continueForwardPolygon); + TrajectorySetStepVehicleLocation unusedStepVehicleLocation; + result = calculateFrontAndSidePolygon(vehicleState, + brakeMaxStepVehicleLocation, + continueForwardSideSteps, + continueForwardFront, + "pedestrian_continue_forward", + continueForwardPolygon, + unusedStepVehicleLocation); if (!result) { - spdlog::debug( - "TrajectoryPedestrian::calculateTrajectorySets>> Error while combining back with continueForwardPolygon."); + spdlog::debug("TrajectoryPedestrian::calculateTrajectorySets>> Could not calculate continueForward polygon."); } } @@ -344,107 +385,42 @@ Polygon TrajectoryPedestrian::calculateSidePolygon(situation::VehicleState const return hull; } -TrajectoryPoint TrajectoryPedestrian::calculateFinalPoint(TrajectoryPoint const &pointAfterResponseTime, - physics::Distance const &distance) const +void TrajectoryPedestrian::calculateTrajectoryPointStraight(TrajectoryPoint const ¤tPoint, + physics::Distance const &distance, + TrajectoryPoint &resultPoint) const { + resultPoint = currentPoint; if (distance > physics::Distance(0.)) { - auto finalPoint = pointAfterResponseTime; - auto headingAngle = pointAfterResponseTime.angle - ad::physics::cPI_2; - finalPoint.position = pointAfterResponseTime.position - + toPoint(-std::sin(headingAngle) * distance, std::cos(headingAngle) * distance); - return finalPoint; - } - else - { - return pointAfterResponseTime; + resultPoint.position = currentPoint.position + + toPoint(std::cos(currentPoint.angle) * distance, std::sin(currentPoint.angle) * distance); } } -bool TrajectoryPedestrian::calculateStepPolygon(situation::VehicleState const &vehicleState, - physics::Distance const &distance, - TrajectorySetStep const &step, - std::string const &debugNamespace, - Polygon &polygon) const +void TrajectoryPedestrian::calculateTrajectoryPointsStraight(physics::Distance const &distance, + TrajectorySetStep const &step, + TrajectorySetStep &resultStep) const { - auto result = true; - - // calculate final points - TrajectorySetStep finalStep; if (distance > physics::Distance(0.)) { for (auto const &left : step.left) { - finalStep.left.push_back(calculateFinalPoint(left, distance)); + TrajectoryPoint pt; + calculateTrajectoryPointStraight(left, distance, pt); + resultStep.left.push_back(pt); } for (auto const &right : step.right) { - finalStep.right.push_back(calculateFinalPoint(right, distance)); + TrajectoryPoint pt; + calculateTrajectoryPointStraight(right, distance, pt); + resultStep.right.push_back(pt); } - finalStep.center = calculateFinalPoint(step.center, distance); + calculateTrajectoryPointStraight(step.center, distance, resultStep.center); } else { - finalStep = step; + resultStep = step; } - - MultiPoint ptsLeft; - MultiPoint ptsRight; - - auto finalCenterFrontLeft - = getVehicleCorner(finalStep.center, vehicleState.objectState.dimension, VehicleCorner::frontLeft); - auto finalCenterFrontRight - = getVehicleCorner(finalStep.center, vehicleState.objectState.dimension, VehicleCorner::frontRight); - - //---- - // left - //---- - int idx = 0; - for (auto it = finalStep.left.begin(); (it != finalStep.left.end()) && result; ++it) - { - if (DEBUG_DRAWING_IS_ENABLED()) - { - auto vehicleLocation = TrafficParticipantLocation(*it, vehicleState); - DEBUG_DRAWING_POLYGON(vehicleLocation.toPolygon(), "black", debugNamespace + "_left_" + std::to_string(idx)); - } - ++idx; - boost::geometry::append(ptsLeft, - getVehicleCorner(*it, vehicleState.objectState.dimension, VehicleCorner::frontRight)); - boost::geometry::append(ptsLeft, - getVehicleCorner(*it, vehicleState.objectState.dimension, VehicleCorner::frontLeft)); - } - boost::geometry::append(ptsLeft, finalCenterFrontLeft); - boost::geometry::append(ptsLeft, finalCenterFrontRight); - - //----- - // right - //----- - idx = 0; - for (auto it = finalStep.right.begin(); (it != finalStep.right.end()) && result; ++it) - { - if (DEBUG_DRAWING_IS_ENABLED()) - { - auto vehicleLocation = TrafficParticipantLocation(*it, vehicleState); - DEBUG_DRAWING_POLYGON(vehicleLocation.toPolygon(), "black", debugNamespace + "_right_" + std::to_string(idx)); - } - ++idx; - boost::geometry::append(ptsRight, - getVehicleCorner(*it, vehicleState.objectState.dimension, VehicleCorner::frontLeft)); - boost::geometry::append(ptsRight, - getVehicleCorner(*it, vehicleState.objectState.dimension, VehicleCorner::frontRight)); - } - boost::geometry::append(ptsRight, finalCenterFrontLeft); - boost::geometry::append(ptsRight, finalCenterFrontRight); - - if (result) - { - Polygon hullLeft; - Polygon hullRight; - boost::geometry::convex_hull(ptsLeft, hullLeft); - boost::geometry::convex_hull(ptsRight, hullRight); - result = combinePolygon(hullLeft, hullRight, polygon); - } - return result; } bool TrajectoryPedestrian::getResponseTimeTrajectoryPoints(situation::VehicleState const &vehicleState, @@ -455,12 +431,17 @@ bool TrajectoryPedestrian::getResponseTimeTrajectoryPoints(situation::VehicleSta //------------- // back //------------- + auto ratioDiffBack = physics::RatioValue( + 2.0 / (2.0 * vehicleState.dynamics.unstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + 2.0)); for (auto ratioValue = physics::RatioValue(-1.0); (ratioValue <= physics::RatioValue(1.0)) && result; - ratioValue += physics::RatioValue(0.1)) + ratioValue += ratioDiffBack) { - auto accel = vehicleState.dynamics.alphaLon.brakeMax; - TrajectoryPoint pt; - result = getResponseTimeTrajectoryPoint(vehicleState, accel, ratioValue, pt); + TrajectoryPoint pt(vehicleState); + result = calculateTrajectoryPoint(pt, + vehicleState.dynamics, + vehicleState.dynamics.responseTime, + vehicleState.dynamics.alphaLon.brakeMax, + ratioValue); if (ratioValue == physics::RatioValue(0.)) { backSide.center = pt; @@ -478,12 +459,17 @@ bool TrajectoryPedestrian::getResponseTimeTrajectoryPoints(situation::VehicleSta //------------- // front //------------- + auto ratioDiffFront = physics::RatioValue( + 2.0 / (2.0 * vehicleState.dynamics.unstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + 2.0)); for (auto ratioValue = physics::RatioValue(-1.0); (ratioValue <= physics::RatioValue(1.0)) && result; - ratioValue += physics::RatioValue(0.1)) + ratioValue += ratioDiffFront) { - auto accel = vehicleState.dynamics.alphaLon.accelMax; - TrajectoryPoint pt; - result = getResponseTimeTrajectoryPoint(vehicleState, accel, ratioValue, pt); + TrajectoryPoint pt(vehicleState); + result = calculateTrajectoryPoint(pt, + vehicleState.dynamics, + vehicleState.dynamics.responseTime, + vehicleState.dynamics.alphaLon.accelMax, + ratioValue); if (ratioValue == physics::RatioValue(0.)) { frontSide.center = pt; @@ -501,65 +487,50 @@ bool TrajectoryPedestrian::getResponseTimeTrajectoryPoints(situation::VehicleSta return result; } -bool TrajectoryPedestrian::getResponseTimeTrajectoryPoint(situation::VehicleState const &vehicleState, - ad::physics::Acceleration const &aUntilResponseTime, - ad::physics::RatioValue const &angleChangeRatio, - TrajectoryPoint &resultTrajectoryPoint) const +bool TrajectoryPedestrian::calculateTrajectoryPoint(TrajectoryPoint ¤tPoint, + world::RssDynamics const &dynamics, + physics::Duration const &duration, + ad::physics::Acceleration const &acceleration, + ad::physics::RatioValue const &angleChangeRatio) const { - auto result = true; - auto startingAngle = vehicleState.objectState.yaw - ad::physics::cPI_2; - auto startingPoint = toPoint(vehicleState.objectState.centerPoint); - ad::physics::Speed speed; - ad::physics::Distance maxDistance; - situation::calculateSpeedAndDistanceOffset(vehicleState.dynamics.responseTime, - vehicleState.objectState.speed, - vehicleState.dynamics.responseTime, - vehicleState.dynamics.maxSpeedOnAcceleration, - aUntilResponseTime, - aUntilResponseTime, - speed, - maxDistance); - - Line linePts; - boost::geometry::append(linePts, startingPoint); - - TrajectoryPoint currentPoint(vehicleState); - - Point pointAfterResponseTime; - auto angleChange = physics::Angle(0.); + ad::physics::Distance distance; + auto result = situation::calculateAcceleratedLimitedMovement( + currentPoint.speed, dynamics.maxSpeedOnAcceleration, acceleration, duration, currentPoint.speed, distance); + + calculateTrajectoryPoint(currentPoint, dynamics, distance, angleChangeRatio); + return result; +} + +void TrajectoryPedestrian::calculateTrajectoryPoint(TrajectoryPoint ¤tPoint, + world::RssDynamics const &dynamics, + physics::Distance const &distance, + ad::physics::RatioValue const &angleChangeRatio) const +{ + if (distance == physics::Distance(0.)) + { + return; + } + if (static_cast(std::fabs(angleChangeRatio)) - > vehicleState.dynamics.unstructuredSettings.pedestrianTurningRadius / maxRadius) + > dynamics.unstructuredSettings.pedestrianTurningRadius / maxRadius) { // move on circle - auto radius = vehicleState.dynamics.unstructuredSettings.pedestrianTurningRadius / angleChangeRatio; - - auto circleOrigin = getCircleOrigin(startingPoint, radius, startingAngle); - ad::physics::Distance distanceUntilReponseTime; + auto radius = dynamics.unstructuredSettings.pedestrianTurningRadius / angleChangeRatio; - situation::calculateAcceleratedLimitedMovement(vehicleState.objectState.speed, - vehicleState.dynamics.maxSpeedOnAcceleration, - aUntilResponseTime, - vehicleState.dynamics.responseTime, - speed, - distanceUntilReponseTime); + auto startingAngle = currentPoint.angle - ad::physics::cPI_2; + auto circleOrigin = getCircleOrigin(currentPoint.position, radius, startingAngle); - angleChange = ad::physics::Angle(distanceUntilReponseTime / radius); + auto angleChange = ad::physics::Angle(distance / radius); - pointAfterResponseTime = getPointOnCircle(circleOrigin, radius, startingAngle + angleChange); + currentPoint.position = getPointOnCircle(circleOrigin, radius, startingAngle + angleChange); + currentPoint.angle += angleChange; } else { // straight line - pointAfterResponseTime - = startingPoint + toPoint(-std::sin(startingAngle) * maxDistance, std::cos(startingAngle) * maxDistance); + currentPoint.position = currentPoint.position + + toPoint(std::cos(currentPoint.angle) * distance, std::sin(currentPoint.angle) * distance); } - boost::geometry::append(linePts, pointAfterResponseTime); - - resultTrajectoryPoint = TrajectoryPoint( - pointAfterResponseTime, vehicleState.objectState.yaw + angleChange, speed, physics::AngularVelocity(0.)); - DEBUG_DRAWING_LINE( - linePts, "orange", std::to_string(aUntilResponseTime) + "_" + std::to_string(angleChangeRatio) + "_trajectory"); - return result; } } // namespace unstructured diff --git a/ad_rss/impl/src/unstructured/TrajectoryPedestrian.hpp b/ad_rss/impl/src/unstructured/TrajectoryPedestrian.hpp index c660080da4..5ccfc92b11 100644 --- a/ad_rss/impl/src/unstructured/TrajectoryPedestrian.hpp +++ b/ad_rss/impl/src/unstructured/TrajectoryPedestrian.hpp @@ -63,21 +63,6 @@ class TrajectoryPedestrian Polygon &continueForwardPolygon); private: - /** - * @brief calculate step polygon - * - * @param[in] step the front points - * @param[in] vehicleDimension vehicle dimension - * @param[out] resultPolygon polygon describing the front - * - * @returns false if a failure occurred during calculations, true otherwise - */ - bool calculateStepPolygon(situation::VehicleState const &vehicleState, - physics::Distance const &distance, - TrajectorySetStep const &step, - std::string const &debugNamespace, - Polygon &polygon) const; - /** * @brief Calculate all trajectory points at response time * @@ -92,30 +77,58 @@ class TrajectoryPedestrian TrajectorySetStep &backSide) const; /** - * @brief Calculate a single trajectory point at response time + * @brief Calculate a single trajectory point * - * @param[in] vehicleState current state of the vehicle - * @param[in] aUntilResponseTime acceleration until response time - * @param[in] yawRateChangeRatio yaw rate change ratio - * @param[out] resultTrajectoryPoint resulting trajectory point + * @param[inout] currentPoint point to use for calculation + * @param[in] dynamics current dynamics of the vehicle + * @param[in] duration duration of movement + * @param[in] acceleration acceleration to apply + * @param[in] yawRateChangeRatio heading change ratio + * + * @returns false if a failure occurred during calculations, true otherwise + */ + bool calculateTrajectoryPoint(TrajectoryPoint ¤tPoint, + world::RssDynamics const &dynamics, + physics::Duration const &duration, + ad::physics::Acceleration const &acceleration, + ad::physics::RatioValue const &yawRateChangeRatio) const; + + /** + * @brief Calculate a single trajectory point + * + * @param[inout] currentPoint point to use for calculation + * @param[in] dynamics current dynamics of the vehicle + * @param[in] distance distance to move + * @param[in] yawRateChangeRatio heading change ratio * * @returns false if a failure occurred during calculations, true otherwise */ - bool getResponseTimeTrajectoryPoint(situation::VehicleState const &vehicleState, - ad::physics::Acceleration const &aUntilResponseTime, - ad::physics::RatioValue const &yawRateChangeRatio, - TrajectoryPoint &resultTrajectoryPoint) const; + void calculateTrajectoryPoint(TrajectoryPoint ¤tPoint, + world::RssDynamics const &dynamics, + physics::Distance const &distance, + ad::physics::RatioValue const &angleChangeRatio) const; /** - * @brief Calculate the final point after response time + * @brief Calculate a point on a straight line * - * @param[in] pointAfterResponseTime point at response time - * @param[in] distance distance of the final point + * @param[in] currentPoint point at response time + * @param[in] distance distance of the final point + * @param[out] resultPoint resulting point + */ + void calculateTrajectoryPointStraight(TrajectoryPoint const ¤tPoint, + physics::Distance const &distance, + TrajectoryPoint &resultPoint) const; + + /** + * @brief Calculate points of trajectory set step on a straight line * - * @returns final point + * @param[in] distance distance of the final points + * @param[in] step current step + * @param[out] resultStep resulting step */ - TrajectoryPoint calculateFinalPoint(TrajectoryPoint const &pointAfterResponseTime, - physics::Distance const &distance) const; + void calculateTrajectoryPointsStraight(physics::Distance const &distance, + TrajectorySetStep const &step, + TrajectorySetStep &resultStep) const; /** * @brief Calculate a side polygon diff --git a/ad_rss/impl/src/unstructured/TrajectoryVehicle.cpp b/ad_rss/impl/src/unstructured/TrajectoryVehicle.cpp index 96e0cb449f..c00ba7aeb0 100644 --- a/ad_rss/impl/src/unstructured/TrajectoryVehicle.cpp +++ b/ad_rss/impl/src/unstructured/TrajectoryVehicle.cpp @@ -92,165 +92,154 @@ bool TrajectoryVehicle::calculateTrajectorySets(situation::VehicleState const &v } } DEBUG_DRAWING_POLYGON(brakePolygon, "red", "vehicle_brake"); - DEBUG_DRAWING_POLYGON(continueForwardPolygon, "green", "vehicle_continueForward"); + DEBUG_DRAWING_POLYGON(continueForwardPolygon, "green", "vehicle_continue_forward"); return result; } ad::physics::AngularVelocity -TrajectoryVehicle::calculateYawRate(situation::VehicleState const &vehicleState, - ad::physics::Duration const &timeInMovementUntilResponseTime, +TrajectoryVehicle::calculateYawRate(ad::physics::AngularVelocity const &yawRate, + ad::physics::Duration const &timeInMovement, ad::physics::AngularAcceleration const &maxYawRateChange, ad::physics::RatioValue const &ratio) const { - return vehicleState.objectState.yawRate + maxYawRateChange * timeInMovementUntilResponseTime * ratio; + return yawRate + maxYawRateChange * timeInMovement * ratio; } bool TrajectoryVehicle::getResponseTimeTrajectoryPoints(situation::VehicleState const &vehicleState, TrajectorySetStep &frontSide, TrajectorySetStep &backSide) const { - auto result = true; //------------- // back //------------- - { - auto ratioDiffBack = physics::RatioValue( - 2.0 / (2.0 * vehicleState.dynamics.unstructuredSettings.vehicleBackIntermediateRatioSteps + 2.0)); - auto accel = vehicleState.dynamics.alphaLon.brakeMax; - physics::Duration timeInMovementUntilResponseTime; - result = getTimeInMovementUntilResponse(vehicleState, accel, timeInMovementUntilResponseTime); - for (auto ratioValue = physics::RatioValue(-1.0); (ratioValue <= physics::RatioValue(1.0)) && result; - ratioValue += ratioDiffBack) - { - TrajectoryPoint pt; - result = getResponseTimeTrajectoryPoint(vehicleState, timeInMovementUntilResponseTime, accel, ratioValue, pt); - if (ratioValue == physics::RatioValue(0.)) - { - backSide.center = pt; - } - else if (ratioValue > physics::RatioValue(0.)) - { - backSide.left.push_back(pt); - } - else - { - backSide.right.push_back(pt); - } - } - } + auto ratioDiffBack = physics::RatioValue( + 2.0 / (2.0 * vehicleState.dynamics.unstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + 2.0)); + backSide.left.reserve(vehicleState.dynamics.unstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + 1); + backSide.right.reserve(vehicleState.dynamics.unstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + 1); + auto result + = getResponseTimeTrajectoryPoints(vehicleState, vehicleState.dynamics.alphaLon.brakeMax, ratioDiffBack, backSide); //------------- // front //------------- + if (result) { auto ratioDiffFront = physics::RatioValue( - 2.0 / (2.0 * vehicleState.dynamics.unstructuredSettings.vehicleFrontIntermediateRatioSteps + 2.0)); + 2.0 / (2.0 * vehicleState.dynamics.unstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + 2.0)); + frontSide.left.reserve(vehicleState.dynamics.unstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + + 1); + frontSide.right.reserve(vehicleState.dynamics.unstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + + 1); + result = getResponseTimeTrajectoryPoints( + vehicleState, vehicleState.dynamics.alphaLon.accelMax, ratioDiffFront, frontSide); + } + return result; +} - auto accel = vehicleState.dynamics.alphaLon.accelMax; - physics::Duration timeInMovementUntilResponseTime; - result = getTimeInMovementUntilResponse(vehicleState, accel, timeInMovementUntilResponseTime); - for (auto ratioValue = physics::RatioValue(-1.0); (ratioValue <= physics::RatioValue(1.0)) && result; - ratioValue += ratioDiffFront) - { - TrajectoryPoint pt; - result = getResponseTimeTrajectoryPoint(vehicleState, timeInMovementUntilResponseTime, accel, ratioValue, pt); - if (ratioValue == physics::RatioValue(0.)) - { - frontSide.center = pt; - } - else if (ratioValue > physics::RatioValue(0.)) - { - frontSide.left.push_back(pt); - } - else - { - frontSide.right.push_back(pt); - } - } +bool TrajectoryVehicle::getResponseTimeTrajectoryPoints(situation::VehicleState const &vehicleState, + physics::Acceleration const &acceleration, + physics::RatioValue const &ratioDiff, + TrajectorySetStep &step) const +{ + physics::Duration timeInMovementUntilResponseTime = vehicleState.dynamics.responseTime; + auto result = getTimeInMovement(vehicleState.objectState.speed, acceleration, timeInMovementUntilResponseTime); + + // right + for (auto ratioValue = physics::RatioValue(-1.0); (ratioValue < physics::RatioValue(0.0)) && result; + ratioValue += ratioDiff) + { + auto currentPoint = TrajectoryPoint(vehicleState); + TrajectoryPoint pt; + result = calculateTrajectoryPoint( + currentPoint, vehicleState.dynamics, timeInMovementUntilResponseTime, acceleration, ratioValue, pt); + step.right.push_back(pt); + } + + // left + for (auto ratioValue = ratioDiff; (ratioValue <= physics::RatioValue(1.0)) && result; ratioValue += ratioDiff) + { + auto currentPoint = TrajectoryPoint(vehicleState); + TrajectoryPoint pt; + result = calculateTrajectoryPoint( + currentPoint, vehicleState.dynamics, timeInMovementUntilResponseTime, acceleration, ratioValue, pt); + step.left.push_back(pt); + } + + // center + if (result) + { + result = calculateTrajectoryPoint(TrajectoryPoint(vehicleState), + vehicleState.dynamics, + timeInMovementUntilResponseTime, + acceleration, + physics::RatioValue(0.), + step.center); } + return result; } -bool TrajectoryVehicle::getTimeInMovementUntilResponse(situation::VehicleState const &vehicleState, - ad::physics::Acceleration const &aUntilResponseTime, - ad::physics::Duration &timeInMovementUntilResponseTime) const +bool TrajectoryVehicle::getTimeInMovement(ad::physics::Speed const &speed, + ad::physics::Acceleration const &acceleration, + ad::physics::Duration &timeInMovement) const { auto result = true; - timeInMovementUntilResponseTime = vehicleState.dynamics.responseTime; // until this time, the yaw rate changes - if (aUntilResponseTime < physics::Acceleration(0.)) + if (acceleration < physics::Acceleration(0.)) { - if (vehicleState.objectState.speed == physics::Speed(0.)) + if (speed == physics::Speed(0.)) { - timeInMovementUntilResponseTime = physics::Duration(0.); + timeInMovement = physics::Duration(0.); } else { - result = situation::calculateTimeToStop(vehicleState.objectState.speed, - vehicleState.dynamics.responseTime, - vehicleState.dynamics.maxSpeedOnAcceleration, - aUntilResponseTime, - aUntilResponseTime, - timeInMovementUntilResponseTime); - if (!result) - { - spdlog::debug("TrajectoryVehicle::getResponseTimeTrajectoryPoint>> Could not calculate time to stop for speed " - "{}, responseTime {}, acceleration {}", - vehicleState.objectState.speed, - vehicleState.dynamics.responseTime, - aUntilResponseTime); - } - timeInMovementUntilResponseTime = std::min(vehicleState.dynamics.responseTime, timeInMovementUntilResponseTime); + physics::Duration timeToStop; + result + = situation::calculateTimeToStop(speed, physics::Duration(0.), speed, acceleration, acceleration, timeToStop); + + timeInMovement = std::min(timeInMovement, timeToStop); } } return result; } -bool TrajectoryVehicle::getResponseTimeTrajectoryPoint(situation::VehicleState const &vehicleState, - ad::physics::Duration const &timeInMovementUntilResponseTime, - ad::physics::Acceleration const &aUntilResponseTime, - ad::physics::RatioValue const &yawRateChangeRatio, - TrajectoryPoint &resultTrajectoryPoint) const +bool TrajectoryVehicle::calculateTrajectoryPoint(TrajectoryPoint const ¤tPoint, + world::RssDynamics const &dynamics, + ad::physics::Duration const &duration, + ad::physics::Acceleration const &acceleration, + ad::physics::RatioValue const &yawRateChangeRatio, + TrajectoryPoint &resultTrajectoryPoint) const { auto result = true; - TrajectoryPoint currentPoint(vehicleState); + resultTrajectoryPoint = currentPoint; auto currentTime = ad::physics::Duration(0.0); - while ((currentTime < vehicleState.dynamics.responseTime) && result) + while ((currentTime < duration) && result) { - auto timeStep = vehicleState.dynamics.unstructuredSettings.vehicleTrajectoryCalculationStep; - if (vehicleState.dynamics.responseTime - >= currentTime + vehicleState.dynamics.unstructuredSettings.vehicleTrajectoryCalculationStep) + auto timeStep = dynamics.unstructuredSettings.vehicleTrajectoryCalculationStep; + if (duration >= currentTime + dynamics.unstructuredSettings.vehicleTrajectoryCalculationStep) { - currentTime += vehicleState.dynamics.unstructuredSettings.vehicleTrajectoryCalculationStep; + currentTime += dynamics.unstructuredSettings.vehicleTrajectoryCalculationStep; } else { - currentTime = vehicleState.dynamics.responseTime; - timeStep = physics::Duration( - std::fmod(static_cast(vehicleState.dynamics.responseTime), - static_cast(vehicleState.dynamics.unstructuredSettings.vehicleTrajectoryCalculationStep))); + timeStep = duration - currentTime; + currentTime = duration; } - currentPoint.yawRate = calculateYawRate(vehicleState, - std::min(currentTime, timeInMovementUntilResponseTime), - vehicleState.dynamics.unstructuredSettings.vehicleYawRateChange, - yawRateChangeRatio); + resultTrajectoryPoint.yawRate = calculateYawRate( + currentPoint.yawRate, currentTime, dynamics.unstructuredSettings.vehicleYawRateChange, yawRateChangeRatio); - result = calculateNextTrajectoryPoint(currentPoint, aUntilResponseTime, timeStep, vehicleState.dynamics); + result = calculateTrajectoryPointOnCircle(resultTrajectoryPoint, acceleration, timeStep, dynamics); } - if (result) - { - resultTrajectoryPoint = currentPoint; - } return result; } -bool TrajectoryVehicle::calculateNextTrajectoryPoint(TrajectoryPoint ¤tPoint, - physics::Acceleration const &acceleration, - physics::Duration const &duration, - ::ad::rss::world::RssDynamics const &dynamics) const +bool TrajectoryVehicle::calculateTrajectoryPointOnCircle(TrajectoryPoint ¤tPoint, + physics::Acceleration const &acceleration, + physics::Duration const &duration, + ::ad::rss::world::RssDynamics const &dynamics) const { ad::physics::Distance currentDistance; physics::Speed finalSpeed; @@ -264,7 +253,8 @@ bool TrajectoryVehicle::calculateNextTrajectoryPoint(TrajectoryPoint ¤tPoi currentPoint.speed, dynamics.maxSpeedOnAcceleration, acceleration, duration, finalSpeed, currentDistance); if (!result) { - spdlog::debug("TrajectoryVehicle::calculateNextTrajectoryPoint>> calculateAcceleratedLimitedMovement() failed."); + spdlog::debug( + "TrajectoryVehicle::calculateTrajectoryPointOnCircle>> calculateAcceleratedLimitedMovement() failed."); } auto currentRadius = physics::Distance::getMax(); @@ -326,16 +316,16 @@ bool TrajectoryVehicle::calculateBrake(situation::VehicleState const &vehicleSta timeAfterResponseTime); } } - + auto backSide = responseTimeBackSide; if (result) { - result = calculateStepPolygon(vehicleState, - timeToStopBrakeMax, - responseTimeBackSide, - vehicleState.dynamics.alphaLon.brakeMax, - "vehicle_brake_brakeMax", - resultPolygon, - brakeMaxVehicleLocations); + calculateTrajectorySetStepOnCircle( + vehicleState, timeToStopBrakeMax, vehicleState.dynamics.alphaLon.brakeMax, backSide); + } + if (result) + { + result + = calculateStepPolygon(vehicleState, backSide, "vehicle_brake_brakeMax", resultPolygon, brakeMaxVehicleLocations); if (!result) { spdlog::debug("TrajectoryVehicle::calculateBrake>> Could not calculate brake max step polygon."); @@ -347,6 +337,15 @@ bool TrajectoryVehicle::calculateBrake(situation::VehicleState const &vehicleSta //------------- if (result) { + // front + auto front = responseTimeFrontSide; + if (result) + { + result = calculateTrajectorySetStepOnCircle( + vehicleState, timeAfterResponseTime, vehicleState.dynamics.alphaLon.brakeMin, front); + } + + // sides std::vector accelerations; auto accelStepSize = (-vehicleState.dynamics.alphaLon.brakeMax + vehicleState.dynamics.alphaLon.brakeMin) / (1.0 + vehicleState.dynamics.unstructuredSettings.vehicleBrakeIntermediateAccelerationSteps); @@ -358,14 +357,40 @@ bool TrajectoryVehicle::calculateBrake(situation::VehicleState const &vehicleSta } accelerations.push_back(vehicleState.dynamics.alphaLon.brakeMin); - result = calculateTrajectorySetFrontAndSide(vehicleState, - timeAfterResponseTime, - responseTimeFrontSide, - brakeMaxVehicleLocations, - accelerations, - "vehicle_brake", - resultPolygon, - brakeMinStepVehicleLocation); + std::vector sideSteps; + for (auto itAcceleration = accelerations.cbegin(); (itAcceleration != accelerations.cend()) && result; + ++itAcceleration) + { + physics::Duration calculationTime = timeAfterResponseTime; + result = getTimeInMovement(responseTimeFrontSide.center.speed, *itAcceleration, calculationTime); + + if (result) + { + TrajectorySetStep sideStep; + sideStep.center = responseTimeFrontSide.center; + sideStep.left.push_back(responseTimeFrontSide.left.back()); + sideStep.right.push_back(responseTimeFrontSide.right.front()); + + result = calculateTrajectorySetStepOnCircle(vehicleState, calculationTime, *itAcceleration, sideStep); + sideSteps.push_back(sideStep); + } + if (!result) + { + spdlog::debug("TrajectoryVehicle::calculateFrontAndSidePolygon>> Could not calculate step polygon for " + "speed {}, acceleration {}, calcTime {}", + responseTimeFrontSide.center.speed, + *itAcceleration, + calculationTime); + } + } + + result = calculateFrontAndSidePolygon(vehicleState, + brakeMaxVehicleLocations, + sideSteps, + front, + "vehicle_brake", + resultPolygon, + brakeMinStepVehicleLocation); if (!result) { spdlog::debug("TrajectoryVehicle::calculateBrake>> Could not calculate front and side polygon."); @@ -381,6 +406,92 @@ bool TrajectoryVehicle::calculateContinueForward(situation::VehicleState const & TrajectorySetStepVehicleLocation const &brakeMinStepVehicleLocation, Polygon &resultPolygon) const { + //----------- + // Front + //----------- + auto ratioDiffFront = physics::RatioValue( + 2.0 / (2.0 * vehicleState.dynamics.unstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + + 2.0)); + auto front = responseTimeFrontSide; + // center-front, with no change of the current yaw rate + auto result = calculateTrajectorySetStepOnCircle( + vehicleState, timeAfterResponseTime, vehicleState.dynamics.alphaLon.accelMax, front); + if (DEBUG_DRAWING_IS_ENABLED()) + { + int idx = 0; + for (auto const &pt : front.left) + { + DEBUG_DRAWING_POLYGON(TrafficParticipantLocation(pt, vehicleState).toPolygon(), + "blue", + "vehicle_continue_forward_front_left_" + std::to_string(idx)); + idx++; + } + idx = 0; + for (auto const &pt : front.right) + { + DEBUG_DRAWING_POLYGON(TrafficParticipantLocation(pt, vehicleState).toPolygon(), + "blue", + "vehicle_continue_forward_front_right_" + std::to_string(idx)); + idx++; + } + DEBUG_DRAWING_POLYGON(TrafficParticipantLocation(front.center, vehicleState).toPolygon(), + "blue", + "vehicle_continue_forward_front_center"); + } + + // center-left, with maximum changing of the yaw rate + front.left.reserve( + front.left.size() + + vehicleState.dynamics.unstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + + 1); + for (auto ratioValue = ratioDiffFront; (ratioValue <= physics::RatioValue(1.0)) && result; + ratioValue += ratioDiffFront) + { + TrajectoryPoint resultPt; + result = calculateTrajectoryPoint(responseTimeFrontSide.left.back(), + vehicleState.dynamics, + timeAfterResponseTime, + vehicleState.dynamics.alphaLon.accelMax, + ratioValue, + resultPt); + front.left.push_back(resultPt); + if (DEBUG_DRAWING_IS_ENABLED()) + { + DEBUG_DRAWING_POLYGON(TrafficParticipantLocation(resultPt, vehicleState).toPolygon(), + "pink", + "vehicle_continue_forward_maxLeft_" + std::to_string(ratioValue)); + } + } + + // center-right, with maximum changing of the yaw rate + std::vector right; + right.reserve(vehicleState.dynamics.unstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + + 1); + for (auto ratioValue = physics::RatioValue(-1.0); (ratioValue < physics::RatioValue(0.0)) && result; + ratioValue += ratioDiffFront) + { + TrajectoryPoint resultPt; + result = calculateTrajectoryPoint(responseTimeFrontSide.right.front(), + vehicleState.dynamics, + timeAfterResponseTime, + vehicleState.dynamics.alphaLon.accelMax, + ratioValue, + resultPt); + right.push_back(resultPt); + if (DEBUG_DRAWING_IS_ENABLED()) + { + DEBUG_DRAWING_POLYGON(TrafficParticipantLocation(resultPt, vehicleState).toPolygon(), + "pink", + std::string("vehicle_continue_forward_maxRight_" + std::to_string(ratioValue))); + } + } + auto previousRight = std::move(front.right); + front.right = right; + front.right.insert(front.right.end(), previousRight.begin(), previousRight.end()); + + //----------- + // Sides + //----------- std::vector accelerations; auto accelStepSize = (vehicleState.dynamics.alphaLon.accelMax - vehicleState.dynamics.alphaLon.brakeMin) / (1.0 + vehicleState.dynamics.unstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps); @@ -391,310 +502,104 @@ bool TrajectoryVehicle::calculateContinueForward(situation::VehicleState const & accelerations.push_back(acceleration); } accelerations.push_back(vehicleState.dynamics.alphaLon.accelMax); - - resultPolygon = brakePolygon; - TrajectorySetStepVehicleLocation frontSideStepVehicleLocation; // unused - auto result = calculateTrajectorySetFrontAndSide(vehicleState, - timeAfterResponseTime, - responseTimeFrontSide, - brakeMinStepVehicleLocation, - accelerations, - "vehicle_continueForward", - resultPolygon, - frontSideStepVehicleLocation); - if (!result) - { - spdlog::debug("TrajectoryVehicle::calculateContinueForward>> Could not calculate front and side polygon."); - } - return result; -} - -bool TrajectoryVehicle::calculateTrajectorySetFrontAndSide( - situation::VehicleState const &vehicleState, - physics::Duration const &timeAfterResponseTime, - TrajectorySetStep const &responseTimeFrontSide, - TrajectorySetStepVehicleLocation const &initialStepVehicleLocation, - std::vector const &accelerations, - std::string const &debugNamespace, - Polygon &resultPolygon, - TrajectorySetStepVehicleLocation &frontSideStepVehicleLocation) const -{ - auto result = true; - auto previousStepVehicleLocation = initialStepVehicleLocation; - //------------- - // sides - //------------- + std::vector sideSteps; for (auto itAcceleration = accelerations.begin(); (itAcceleration != accelerations.end()) && result; ++itAcceleration) { physics::Duration calculationTime = timeAfterResponseTime; - if (*itAcceleration < physics::Acceleration(0.)) + result = getTimeInMovement(responseTimeFrontSide.center.speed, *itAcceleration, calculationTime); + + TrajectorySetStep sideStep; + if (result) { - if (responseTimeFrontSide.center.speed == physics::Speed(0.)) - { - calculationTime = physics::Duration(0.); - } - else + // left + TrajectoryPoint resultPt; + result = calculateTrajectoryPoint(responseTimeFrontSide.left.back(), + vehicleState.dynamics, + calculationTime, + *itAcceleration, + physics::RatioValue(1.0), + resultPt); + sideStep.left.push_back(resultPt); + if (DEBUG_DRAWING_IS_ENABLED()) { - physics::Duration timeToStop; - result = situation::calculateTimeToStop(responseTimeFrontSide.center.speed, - timeAfterResponseTime, - vehicleState.dynamics.maxSpeedOnAcceleration, - *itAcceleration, - *itAcceleration, - timeToStop); - calculationTime = std::min(timeToStop, timeAfterResponseTime); + DEBUG_DRAWING_POLYGON(TrafficParticipantLocation(resultPt, vehicleState).toPolygon(), + "pink", + "vehicle_continue_forward_final_location_intermediate_left_" + + std::to_string(*itAcceleration)); } } - Polygon stepPolygon; - TrajectorySetStepVehicleLocation currentStepVehicleLocation; + // center if (result) { - TrajectorySetStep sideStep; sideStep.center = responseTimeFrontSide.center; - sideStep.left.push_back(responseTimeFrontSide.left.back()); - sideStep.right.push_back(responseTimeFrontSide.right.front()); - result = calculateStepPolygon(vehicleState, - calculationTime, - sideStep, - *itAcceleration, - debugNamespace + "_" + std::to_string(*itAcceleration), - stepPolygon, - currentStepVehicleLocation); - if (!result) - { - spdlog::debug("TrajectoryVehicle::calculateTrajectorySetFrontAndSide>> Could not calculate step polygon for " - "speed {}, acceleration {}, calcTime {}", - responseTimeFrontSide.center.speed, - *itAcceleration, - calculationTime); - } + result + = calculateTrajectoryPointOnCircle(sideStep.center, *itAcceleration, calculationTime, vehicleState.dynamics); } + + // right if (result) { - result = calculateEstimationBetweenSteps( - resultPolygon, previousStepVehicleLocation, currentStepVehicleLocation, debugNamespace + "_step_estimation"); - if (!result) + TrajectoryPoint resultPt; + result = calculateTrajectoryPoint(responseTimeFrontSide.right.front(), + vehicleState.dynamics, + calculationTime, + *itAcceleration, + physics::RatioValue(-1.0), + resultPt); + sideStep.right.push_back(resultPt); + if (DEBUG_DRAWING_IS_ENABLED()) { - spdlog::debug("TrajectoryVehicle::calculateTrajectorySetFrontAndSide>> Could not calculate between steps " - "polygon. Speed {}, acceleration {}, calcTime {}", - responseTimeFrontSide.center.speed, - *itAcceleration, - calculationTime); + DEBUG_DRAWING_POLYGON(TrafficParticipantLocation(resultPt, vehicleState).toPolygon(), + "pink", + "vehicle_continue_forward_final_location_intermediate_right_" + + std::to_string(*itAcceleration)); } - previousStepVehicleLocation = currentStepVehicleLocation; - } - - if (result) - { - result = combinePolygon(resultPolygon, stepPolygon, resultPolygon); } + sideSteps.push_back(sideStep); } - //------------- - // front - //------------- - Polygon frontPolygon; - if (result) - { - result = calculateStepPolygon(vehicleState, - timeAfterResponseTime, - responseTimeFrontSide, - accelerations.back(), - debugNamespace + "_front", - frontPolygon, - frontSideStepVehicleLocation); - } - if (result) - { - result = calculateEstimationBetweenSteps( - resultPolygon, previousStepVehicleLocation, frontSideStepVehicleLocation, debugNamespace + "_front_estimation"); - if (!result) - { - spdlog::debug("TrajectoryVehicle::calculateTrajectorySetFrontAndSide>> Could not calculate between last step and " - "front polygon."); - } - } - if (result) + resultPolygon = brakePolygon; + TrajectorySetStepVehicleLocation unusedStepVehicleLocation; + result = calculateFrontAndSidePolygon(vehicleState, + brakeMinStepVehicleLocation, + sideSteps, + front, + "vehicle_continue_forward", + resultPolygon, + unusedStepVehicleLocation); + if (!result) { - result = combinePolygon(resultPolygon, frontPolygon, resultPolygon); + spdlog::debug("TrajectoryVehicle::calculateContinueForward>> Could not calculate front and side polygon."); } return result; } -bool TrajectoryVehicle::calculateStepPolygon(situation::VehicleState const &vehicleState, - physics::Duration const &timeAfterResponseTime, - TrajectorySetStep const &step, - physics::Acceleration const &acceleration, - std::string const &debugNamespace, - Polygon &polygon, - TrajectorySetStepVehicleLocation &stepVehicleLocation) const +bool TrajectoryVehicle::calculateTrajectorySetStepOnCircle(situation::VehicleState const &vehicleState, + physics::Duration const &timeAfterResponseTime, + physics::Acceleration const &acceleration, + TrajectorySetStep &step) const { auto result = true; - MultiPoint frontPtsLeft; - MultiPoint frontPtsRight; - int idx = 0; + // left for (auto it = step.left.begin(); (it != step.left.end()) && result; ++it) { - auto currentPointLeft = *it; - result = calculateNextTrajectoryPoint(currentPointLeft, acceleration, timeAfterResponseTime, vehicleState.dynamics); - auto vehicleLocationLeft = TrafficParticipantLocation(currentPointLeft, vehicleState); - DEBUG_DRAWING_POLYGON(vehicleLocationLeft.toPolygon(), "black", debugNamespace + "_left_" + std::to_string(idx)); - boost::geometry::append(frontPtsLeft, vehicleLocationLeft.toMultiPoint()); - if (it == step.left.end() - 1) - { - stepVehicleLocation.left = vehicleLocationLeft; - } - ++idx; + result = calculateTrajectoryPointOnCircle(*it, acceleration, timeAfterResponseTime, vehicleState.dynamics); } // center if (result) { - auto currentPointCenter = step.center; - result - = calculateNextTrajectoryPoint(currentPointCenter, acceleration, timeAfterResponseTime, vehicleState.dynamics); - auto vehicleLocationCenter = TrafficParticipantLocation(currentPointCenter, vehicleState); - DEBUG_DRAWING_POLYGON(vehicleLocationCenter.toPolygon(), "blue", debugNamespace + "_center"); - boost::geometry::append(frontPtsLeft, vehicleLocationCenter.toMultiPoint()); - stepVehicleLocation.center = vehicleLocationCenter; - boost::geometry::append(frontPtsRight, vehicleLocationCenter.toMultiPoint()); + result = calculateTrajectoryPointOnCircle(step.center, acceleration, timeAfterResponseTime, vehicleState.dynamics); } - idx = 0; + // right for (auto it = step.right.begin(); (it != step.right.end()) && result; ++it) { - auto currentPointRight = *it; - result - = calculateNextTrajectoryPoint(currentPointRight, acceleration, timeAfterResponseTime, vehicleState.dynamics); - auto vehicleLocationRight = TrafficParticipantLocation(currentPointRight, vehicleState); - DEBUG_DRAWING_POLYGON(vehicleLocationRight.toPolygon(), "blue", debugNamespace + "_right_" + std::to_string(idx)); - boost::geometry::append(frontPtsRight, vehicleLocationRight.toMultiPoint()); - if (it == step.right.begin()) - { - stepVehicleLocation.right = vehicleLocationRight; - } - ++idx; - } - - if (result) - { - Polygon hullLeft; - Polygon hullRight; - boost::geometry::convex_hull(frontPtsLeft, hullLeft); - boost::geometry::convex_hull(frontPtsRight, hullRight); - result = combinePolygon(hullLeft, hullRight, polygon); - } - return result; -} - -bool TrajectoryVehicle::calculateEstimationBetweenSteps( - Polygon &polygon, - TrajectorySetStepVehicleLocation const &previousStepVehicleLocation, - TrajectorySetStepVehicleLocation const ¤tStepVehicleLocation, - std::string const &debugNamespace) const -{ - // Fill potential gap between two calculation steps by using the previous and current step - auto result = true; - //------------- - // back - //------------- - if ((previousStepVehicleLocation.left.backLeft != currentStepVehicleLocation.left.backLeft) - || (previousStepVehicleLocation.left.backRight != currentStepVehicleLocation.left.backRight) - || (previousStepVehicleLocation.center.backLeft != currentStepVehicleLocation.center.backLeft) - || (previousStepVehicleLocation.center.backRight != currentStepVehicleLocation.center.backRight)) - { - MultiPoint interimPtsBackLeft; - boost::geometry::append(interimPtsBackLeft, previousStepVehicleLocation.left.backLeft); - boost::geometry::append(interimPtsBackLeft, previousStepVehicleLocation.left.backRight); - boost::geometry::append(interimPtsBackLeft, previousStepVehicleLocation.center.backLeft); - boost::geometry::append(interimPtsBackLeft, previousStepVehicleLocation.center.backRight); - boost::geometry::append(interimPtsBackLeft, currentStepVehicleLocation.left.backLeft); - boost::geometry::append(interimPtsBackLeft, currentStepVehicleLocation.left.backRight); - boost::geometry::append(interimPtsBackLeft, currentStepVehicleLocation.center.backLeft); - boost::geometry::append(interimPtsBackLeft, currentStepVehicleLocation.center.backRight); - Polygon hullBackLeft; - boost::geometry::convex_hull(interimPtsBackLeft, hullBackLeft); - - MultiPoint interimPtsBackRight; - boost::geometry::append(interimPtsBackRight, previousStepVehicleLocation.right.backLeft); - boost::geometry::append(interimPtsBackRight, previousStepVehicleLocation.right.backRight); - boost::geometry::append(interimPtsBackRight, previousStepVehicleLocation.center.backLeft); - boost::geometry::append(interimPtsBackRight, previousStepVehicleLocation.center.backRight); - boost::geometry::append(interimPtsBackRight, currentStepVehicleLocation.right.backLeft); - boost::geometry::append(interimPtsBackRight, currentStepVehicleLocation.right.backRight); - boost::geometry::append(interimPtsBackRight, currentStepVehicleLocation.center.backLeft); - boost::geometry::append(interimPtsBackRight, currentStepVehicleLocation.center.backRight); - Polygon hullBackRight; - boost::geometry::convex_hull(interimPtsBackRight, hullBackRight); - Polygon hullBack; - result = combinePolygon(hullBackRight, hullBackLeft, hullBack); - if (!result) - { - spdlog::debug("TrajectoryVehicle::calculateEstimationBetweenSteps>> Could not estimation polygon with points " - "backLeft {}, backRight {}", - std::to_string(hullBackLeft), - std::to_string(hullBackRight)); - } - - if (result) - { - DEBUG_DRAWING_POLYGON(hullBack, "yellow", debugNamespace + "_hull_back"); - result = combinePolygon(polygon, hullBack, polygon); - } + result = calculateTrajectoryPointOnCircle(*it, acceleration, timeAfterResponseTime, vehicleState.dynamics); } - //------------- - // front - //------------- - if ((previousStepVehicleLocation.left.frontLeft != currentStepVehicleLocation.left.frontLeft) - || (previousStepVehicleLocation.left.frontRight != currentStepVehicleLocation.left.frontRight) - || (previousStepVehicleLocation.center.frontLeft != currentStepVehicleLocation.center.frontLeft) - || (previousStepVehicleLocation.center.frontRight != currentStepVehicleLocation.center.frontRight)) - { - Polygon hullFront; - if (result) - { - MultiPoint interimPtsFrontLeft; - boost::geometry::append(interimPtsFrontLeft, previousStepVehicleLocation.left.frontLeft); - boost::geometry::append(interimPtsFrontLeft, previousStepVehicleLocation.left.frontRight); - boost::geometry::append(interimPtsFrontLeft, previousStepVehicleLocation.center.frontLeft); - boost::geometry::append(interimPtsFrontLeft, previousStepVehicleLocation.center.frontRight); - boost::geometry::append(interimPtsFrontLeft, currentStepVehicleLocation.left.frontLeft); - boost::geometry::append(interimPtsFrontLeft, currentStepVehicleLocation.left.frontRight); - boost::geometry::append(interimPtsFrontLeft, currentStepVehicleLocation.center.frontLeft); - boost::geometry::append(interimPtsFrontLeft, currentStepVehicleLocation.center.frontRight); - Polygon hullFrontLeft; - boost::geometry::convex_hull(interimPtsFrontLeft, hullFrontLeft); - - MultiPoint interimPtsFrontRight; - boost::geometry::append(interimPtsFrontRight, previousStepVehicleLocation.right.frontLeft); - boost::geometry::append(interimPtsFrontRight, previousStepVehicleLocation.right.frontRight); - boost::geometry::append(interimPtsFrontRight, previousStepVehicleLocation.center.frontLeft); - boost::geometry::append(interimPtsFrontRight, previousStepVehicleLocation.center.frontRight); - boost::geometry::append(interimPtsFrontRight, currentStepVehicleLocation.right.frontLeft); - boost::geometry::append(interimPtsFrontRight, currentStepVehicleLocation.right.frontRight); - boost::geometry::append(interimPtsFrontRight, currentStepVehicleLocation.center.frontLeft); - boost::geometry::append(interimPtsFrontRight, currentStepVehicleLocation.center.frontRight); - Polygon hullFrontRight; - boost::geometry::convex_hull(interimPtsFrontRight, hullFrontRight); - result = combinePolygon(hullFrontRight, hullFrontLeft, hullFront); - if (!result) - { - spdlog::debug("TrajectoryVehicle::calculateEstimationBetweenSteps>> Could not estimation polygon with points " - "frontLeft {}, frontRight {}", - std::to_string(hullFrontLeft), - std::to_string(hullFrontRight)); - } - } - - if (result) - { - DEBUG_DRAWING_POLYGON(hullFront, "yellow", debugNamespace + "_hull_front"); - result = combinePolygon(polygon, hullFront, polygon); - } - } return result; } diff --git a/ad_rss/impl/src/unstructured/TrajectoryVehicle.hpp b/ad_rss/impl/src/unstructured/TrajectoryVehicle.hpp index 76ffa153ea..1862a0c4e8 100644 --- a/ad_rss/impl/src/unstructured/TrajectoryVehicle.hpp +++ b/ad_rss/impl/src/unstructured/TrajectoryVehicle.hpp @@ -38,13 +38,6 @@ namespace unstructured { class TrajectoryVehicle { public: - struct TrajectorySetStepVehicleLocation - { - TrafficParticipantLocation left; - TrafficParticipantLocation right; - TrafficParticipantLocation center; - }; - TrajectoryVehicle() { } @@ -66,14 +59,14 @@ class TrajectoryVehicle /** * @brief Calculate the yaw rate after a duration * - * @param[in] vehicleState current state of the vehicle + * @param[in] yawRate current yaw rate * @param[in] timeInMovementUntilResponseTime duration of yaw rate change * @param[in] maxYawRateChange maximum yaw rate change per second * @param[in] ratio yaw rate change ratio * * @returns yaw rate */ - ad::physics::AngularVelocity calculateYawRate(situation::VehicleState const &vehicleState, + ad::physics::AngularVelocity calculateYawRate(ad::physics::AngularVelocity const &yawRate, ad::physics::Duration const &timeInMovementUntilResponseTime, ad::physics::AngularAcceleration const &maxYawRateChange, ad::physics::RatioValue const &ratio) const; @@ -92,24 +85,41 @@ class TrajectoryVehicle TrajectorySetStep &backSide) const; /** - * @brief Calculate a single trajectory point at response time + * @brief Calculate all trajectory points at response time + * + * @param[in] vehicleState current state of the vehicle + * @param[in] acceleration acceleration to use + * @param[in] ratioDiff yaw rate change ratio + * @param[in] step resulting trajectory set step * - * @param[in] vehicleState current state of the vehicle - * @param[in] timeInMovementUntilResponseTime time in movement until response time - * @param[in] aUntilResponseTime acceleration until response time + * @returns false if a failure occurred during calculations, true otherwise + */ + bool getResponseTimeTrajectoryPoints(situation::VehicleState const &vehicleState, + physics::Acceleration const &acceleration, + physics::RatioValue const &ratioDiff, + TrajectorySetStep &step) const; + + /** + * @brief Calculate a single trajectory point with changing radius + * + * @param[in] currentPoint trajectory point to use for calculation + * @param[in] dynamics dynamics to use + * @param[in] duration time + * @param[in] acceleration acceleration to use * @param[in] yawRateChangeRatio yaw rate change ratio * @param[out] resultTrajectoryPoint resulting trajectory point * * @returns false if a failure occurred during calculations, true otherwise */ - bool getResponseTimeTrajectoryPoint(situation::VehicleState const &vehicleState, - ad::physics::Duration const &timeInMovementUntilResponseTime, - ad::physics::Acceleration const &aUntilResponseTime, - ad::physics::RatioValue const &yawRateChangeRatio, - TrajectoryPoint &resultTrajectoryPoint) const; + bool calculateTrajectoryPoint(TrajectoryPoint const ¤tPoint, + world::RssDynamics const &dynamics, + ad::physics::Duration const &duration, + ad::physics::Acceleration const &acceleration, + ad::physics::RatioValue const &yawRateChangeRatio, + TrajectoryPoint &resultTrajectoryPoint) const; /** - * @brief Calculate a next trajectory point using a linear calculation + * @brief Calculate a next trajectory point on a circle * * @param[inout] currentPoint trajectory point to use for calculation * @param[in] acceleration acceleration to use @@ -118,23 +128,23 @@ class TrajectoryVehicle * * @returns false if a failure occurred during calculations, true otherwise */ - bool calculateNextTrajectoryPoint(TrajectoryPoint ¤tPoint, - physics::Acceleration const &acceleration, - physics::Duration const &duration, - ::ad::rss::world::RssDynamics const &dynamics) const; + bool calculateTrajectoryPointOnCircle(TrajectoryPoint ¤tPoint, + physics::Acceleration const &acceleration, + physics::Duration const &duration, + ::ad::rss::world::RssDynamics const &dynamics) const; /** * @brief Calculate a time in movement until response time * - * @param[in] vehicleState current state of the vehicle - * @param[in] aUntilResponseTime acceleration to use - * @param[out] timeInMovementUntilResponseTime resulting time in movement + * @param[in] speed speed of the vehicle + * @param[in] acceleration acceleration to use + * @param[inout] timeInMovement resulting time in movement * * @returns false if a failure occurred during calculations, true otherwise */ - bool getTimeInMovementUntilResponse(situation::VehicleState const &vehicleState, - ad::physics::Acceleration const &aUntilResponseTime, - ad::physics::Duration &timeInMovementUntilResponseTime) const; + bool getTimeInMovement(ad::physics::Speed const &speed, + ad::physics::Acceleration const &acceleration, + ad::physics::Duration &timeInMovement) const; /** * @brief Calculate the brake trajectory set @@ -175,63 +185,19 @@ class TrajectoryVehicle Polygon &resultPolygon) const; /** - * @brief Calculate a trajectory set estimation between two steps - * - * @param[inout] polygon polygon to work on - * @param[in] previousVehicleLocation the previous possible vehicle locations - * @param[in] currentVehicleLocation the current possible vehicle locations - * @param[in] debugNamespace namespace for debugging purposes - * - * @returns false if a failure occurred during calculations, true otherwise - */ - bool calculateEstimationBetweenSteps(Polygon &polygon, - TrajectorySetStepVehicleLocation const &previousVehicleLocation, - TrajectorySetStepVehicleLocation const ¤tVehicleLocation, - std::string const &debugNamespace) const; - - /** - * @brief Calculate a trajectory set for the front and the sides + * @brief Calculate the trajectory set step for a movement on a circle * * @param[in] vehicleState current state of the vehicle * @param[in] timeAfterResponseTime time after the response time to move - * @param[in] responseTimeFrontSide the trajectory points defining the front - * @param[in] initialStepVehicleLocation the vehicle locations for the initial calculation step - * @param[in] accelerations accelerations to calculate - * @param[in] debugNamespace namespace for debugging purposes - * @param[out] resultPolygon the resulting polygon - * @param[out] frontSideStepVehicleLocation vehicle locations of the front side + * @param[in] acceleration acceleration to apply + * @param[in] step resulting trajectory set step * * @returns false if a failure occurred during calculations, true otherwise */ - bool calculateTrajectorySetFrontAndSide(situation::VehicleState const &vehicleState, + bool calculateTrajectorySetStepOnCircle(situation::VehicleState const &vehicleState, physics::Duration const &timeAfterResponseTime, - TrajectorySetStep const &responseTimeFrontSide, - TrajectorySetStepVehicleLocation const &initialStepVehicleLocation, - std::vector const &accelerations, - std::string const &debugNamespace, - Polygon &resultPolygon, - TrajectorySetStepVehicleLocation &frontSideStepVehicleLocation) const; - - /** - * @brief Calculate a polygon for one step - * - * @param[in] vehicleState current state of the vehicle - * @param[in] timeAfterResponseTime time after the response time to move - * @param[in] step step to use for calculations - * @param[in] acceleration acceleration to use - * @param[in] debugNamespace namespace for debugging purposes - * @param[out] polygon the resulting polygon - * @param[out] stepVehicleLocation vehicle locations after calculation - * - * @returns false if a failure occurred during calculations, true otherwise - */ - bool calculateStepPolygon(situation::VehicleState const &vehicleState, - physics::Duration const &timeAfterResponseTime, - TrajectorySetStep const &step, - physics::Acceleration const &acceleration, - std::string const &debugNamespace, - Polygon &polygon, - TrajectorySetStepVehicleLocation &stepVehicleLocation) const; + physics::Acceleration const &acceleration, + TrajectorySetStep &step) const; }; } // namespace unstructured diff --git a/ad_rss/impl/test/generated/ad/rss/situation/SituationSnapshotTests.cpp b/ad_rss/impl/test/generated/ad/rss/situation/SituationSnapshotTests.cpp index b412955774..16ace43176 100644 --- a/ad_rss/impl/test/generated/ad/rss/situation/SituationSnapshotTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/situation/SituationSnapshotTests.cpp @@ -84,14 +84,14 @@ class SituationSnapshotTests : public testing::Test ::ad::physics::Duration valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -100,6 +100,33 @@ class SituationSnapshotTests : public testing::Test std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDefaultEgoVehicleRssDynamics.unstructuredSettings = valueDefaultEgoVehicleRssDynamicsUnstructuredSettings; value.defaultEgoVehicleRssDynamics = valueDefaultEgoVehicleRssDynamics; ::ad::rss::situation::SituationVector valueSituations; @@ -208,14 +235,16 @@ class SituationSnapshotTests : public testing::Test valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -372,14 +401,16 @@ class SituationSnapshotTests : public testing::Test valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; @@ -576,14 +607,14 @@ TEST_F(SituationSnapshotTests, comparisonOperatorDefaultEgoVehicleRssDynamicsDif ::ad::physics::Duration defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(1e6); defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::max()}; defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -592,6 +623,30 @@ TEST_F(SituationSnapshotTests, comparisonOperatorDefaultEgoVehicleRssDynamicsDif std::numeric_limits::max()}; defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; defaultEgoVehicleRssDynamics.unstructuredSettings = defaultEgoVehicleRssDynamicsUnstructuredSettings; valueA.defaultEgoVehicleRssDynamics = defaultEgoVehicleRssDynamics; ::ad::rss::situation::SituationSnapshot valueB = mValue; @@ -689,14 +744,14 @@ TEST_F(SituationSnapshotTests, comparisonOperatorSituationsDiffers) 1e6); situationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = situationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t situationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t situationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - situationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = situationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t situationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + situationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = situationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t situationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - situationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = situationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + situationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = situationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t situationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::max()}; situationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -845,14 +900,15 @@ TEST_F(SituationSnapshotTests, comparisonOperatorSituationsDiffers) situationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(1e6); situationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = situationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t situationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ - std::numeric_limits::max()}; - situationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = situationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t situationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + uint32_t + situationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + situationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = situationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t situationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - situationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = situationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + situationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = situationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t situationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::max()}; situationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps diff --git a/ad_rss/impl/test/generated/ad/rss/situation/SituationSnapshotValidInputRangeTests.cpp b/ad_rss/impl/test/generated/ad/rss/situation/SituationSnapshotValidInputRangeTests.cpp index a694ff4721..18fca44b71 100644 --- a/ad_rss/impl/test/generated/ad/rss/situation/SituationSnapshotValidInputRangeTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/situation/SituationSnapshotValidInputRangeTests.cpp @@ -76,14 +76,14 @@ TEST(SituationSnapshotValidInputRangeTests, testValidInputRange) ::ad::physics::Duration valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -92,6 +92,32 @@ TEST(SituationSnapshotValidInputRangeTests, testValidInputRange) std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDefaultEgoVehicleRssDynamics.unstructuredSettings = valueDefaultEgoVehicleRssDynamicsUnstructuredSettings; value.defaultEgoVehicleRssDynamics = valueDefaultEgoVehicleRssDynamics; ::ad::rss::situation::SituationVector valueSituations; @@ -198,14 +224,16 @@ TEST(SituationSnapshotValidInputRangeTests, testValidInputRange) valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -361,14 +389,16 @@ TEST(SituationSnapshotValidInputRangeTests, testValidInputRange) valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -508,14 +538,14 @@ TEST(SituationSnapshotValidInputRangeTests, testValidInputRangeDefaultEgoVehicle ::ad::physics::Duration valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -524,6 +554,32 @@ TEST(SituationSnapshotValidInputRangeTests, testValidInputRangeDefaultEgoVehicle std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDefaultEgoVehicleRssDynamics.unstructuredSettings = valueDefaultEgoVehicleRssDynamicsUnstructuredSettings; value.defaultEgoVehicleRssDynamics = valueDefaultEgoVehicleRssDynamics; ::ad::rss::situation::SituationVector valueSituations; @@ -630,14 +686,16 @@ TEST(SituationSnapshotValidInputRangeTests, testValidInputRangeDefaultEgoVehicle valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -793,14 +851,16 @@ TEST(SituationSnapshotValidInputRangeTests, testValidInputRangeDefaultEgoVehicle valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -948,14 +1008,14 @@ TEST(SituationSnapshotValidInputRangeTests, testValidInputRangeDefaultEgoVehicle ::ad::physics::Duration valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -964,6 +1024,32 @@ TEST(SituationSnapshotValidInputRangeTests, testValidInputRangeDefaultEgoVehicle std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDefaultEgoVehicleRssDynamics.unstructuredSettings = valueDefaultEgoVehicleRssDynamicsUnstructuredSettings; value.defaultEgoVehicleRssDynamics = valueDefaultEgoVehicleRssDynamics; ::ad::rss::situation::SituationVector valueSituations; @@ -1070,14 +1156,16 @@ TEST(SituationSnapshotValidInputRangeTests, testValidInputRangeDefaultEgoVehicle valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueSituationsElementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1233,14 +1321,16 @@ TEST(SituationSnapshotValidInputRangeTests, testValidInputRangeDefaultEgoVehicle valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ - std::numeric_limits::min()}; - valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueSituationsElementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps diff --git a/ad_rss/impl/test/generated/ad/rss/situation/SituationTests.cpp b/ad_rss/impl/test/generated/ad/rss/situation/SituationTests.cpp index faf21e3700..dfbcb1451b 100644 --- a/ad_rss/impl/test/generated/ad/rss/situation/SituationTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/situation/SituationTests.cpp @@ -103,14 +103,14 @@ class SituationTests : public testing::Test ::ad::physics::Duration valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -119,6 +119,31 @@ class SituationTests : public testing::Test std::numeric_limits::min()}; valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueEgoVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleStateDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleStateDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleStateDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleStateDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleStateDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleStateDynamics.unstructuredSettings = valueEgoVehicleStateDynamicsUnstructuredSettings; valueEgoVehicleState.dynamics = valueEgoVehicleStateDynamics; bool valueEgoVehicleStateHasPriority{true}; @@ -227,14 +252,14 @@ class SituationTests : public testing::Test ::ad::physics::Duration valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -243,6 +268,32 @@ class SituationTests : public testing::Test std::numeric_limits::min()}; valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueOtherVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueOtherVehicleStateDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueOtherVehicleStateDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueOtherVehicleStateDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueOtherVehicleStateDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueOtherVehicleStateDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueOtherVehicleStateDynamics.unstructuredSettings = valueOtherVehicleStateDynamicsUnstructuredSettings; valueOtherVehicleState.dynamics = valueOtherVehicleStateDynamics; bool valueOtherVehicleStateHasPriority{true}; @@ -448,14 +499,14 @@ TEST_F(SituationTests, comparisonOperatorEgoVehicleStateDiffers) ::ad::physics::Duration egoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(1e6); egoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = egoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t egoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t egoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - egoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = egoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t egoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + egoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = egoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t egoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - egoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = egoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + egoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = egoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t egoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::max()}; egoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -464,6 +515,26 @@ TEST_F(SituationTests, comparisonOperatorEgoVehicleStateDiffers) std::numeric_limits::max()}; egoVehicleStateDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = egoVehicleStateDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t egoVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + egoVehicleStateDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = egoVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t egoVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + egoVehicleStateDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = egoVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t egoVehicleStateDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + egoVehicleStateDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = egoVehicleStateDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t egoVehicleStateDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + egoVehicleStateDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = egoVehicleStateDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t egoVehicleStateDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + egoVehicleStateDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = egoVehicleStateDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; egoVehicleStateDynamics.unstructuredSettings = egoVehicleStateDynamicsUnstructuredSettings; egoVehicleState.dynamics = egoVehicleStateDynamics; bool egoVehicleStateHasPriority{false}; @@ -578,14 +649,14 @@ TEST_F(SituationTests, comparisonOperatorOtherVehicleStateDiffers) ::ad::physics::Duration otherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(1e6); otherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = otherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t otherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t otherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - otherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = otherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t otherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + otherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = otherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t otherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - otherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = otherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + otherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = otherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t otherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::max()}; otherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -594,6 +665,30 @@ TEST_F(SituationTests, comparisonOperatorOtherVehicleStateDiffers) std::numeric_limits::max()}; otherVehicleStateDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = otherVehicleStateDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t otherVehicleStateDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + otherVehicleStateDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = otherVehicleStateDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t otherVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + otherVehicleStateDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = otherVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t otherVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + otherVehicleStateDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = otherVehicleStateDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t otherVehicleStateDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + otherVehicleStateDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = otherVehicleStateDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t otherVehicleStateDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + otherVehicleStateDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = otherVehicleStateDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t otherVehicleStateDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + otherVehicleStateDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = otherVehicleStateDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; otherVehicleStateDynamics.unstructuredSettings = otherVehicleStateDynamicsUnstructuredSettings; otherVehicleState.dynamics = otherVehicleStateDynamics; bool otherVehicleStateHasPriority{false}; diff --git a/ad_rss/impl/test/generated/ad/rss/situation/SituationValidInputRangeTests.cpp b/ad_rss/impl/test/generated/ad/rss/situation/SituationValidInputRangeTests.cpp index 8c2aa6cf5f..d3ea077ad9 100644 --- a/ad_rss/impl/test/generated/ad/rss/situation/SituationValidInputRangeTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/situation/SituationValidInputRangeTests.cpp @@ -95,14 +95,14 @@ TEST(SituationValidInputRangeTests, testValidInputRange) ::ad::physics::Duration valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -217,14 +217,14 @@ TEST(SituationValidInputRangeTests, testValidInputRange) ::ad::physics::Duration valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -363,14 +363,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeSituationTypeTooSmall) ::ad::physics::Duration valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -485,14 +485,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeSituationTypeTooSmall) ::ad::physics::Duration valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -635,14 +635,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeSituationTypeTooBig) ::ad::physics::Duration valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -757,14 +757,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeSituationTypeTooBig) ::ad::physics::Duration valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -907,14 +907,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeEgoVehicleStateTooSmall) ::ad::physics::Duration valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1029,14 +1029,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeEgoVehicleStateTooSmall) ::ad::physics::Duration valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1185,14 +1185,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeEgoVehicleStateTooBig) ::ad::physics::Duration valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1307,14 +1307,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeEgoVehicleStateTooBig) ::ad::physics::Duration valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1463,14 +1463,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeOtherVehicleStateTooSmall ::ad::physics::Duration valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1585,14 +1585,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeOtherVehicleStateTooSmall ::ad::physics::Duration valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1741,14 +1741,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeOtherVehicleStateTooBig) ::ad::physics::Duration valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1863,14 +1863,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeOtherVehicleStateTooBig) ::ad::physics::Duration valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -2019,14 +2019,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeRelativePositionTooSmall) ::ad::physics::Duration valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -2141,14 +2141,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeRelativePositionTooSmall) ::ad::physics::Duration valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -2294,14 +2294,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeRelativePositionTooBig) ::ad::physics::Duration valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -2416,14 +2416,14 @@ TEST(SituationValidInputRangeTests, testValidInputRangeRelativePositionTooBig) ::ad::physics::Duration valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps diff --git a/ad_rss/impl/test/generated/ad/rss/situation/SituationVectorValidInputRangeTests.cpp b/ad_rss/impl/test/generated/ad/rss/situation/SituationVectorValidInputRangeTests.cpp index fbbe44f573..11e5acdf56 100644 --- a/ad_rss/impl/test/generated/ad/rss/situation/SituationVectorValidInputRangeTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/situation/SituationVectorValidInputRangeTests.cpp @@ -103,14 +103,14 @@ TEST(SituationVectorValidInputRangeTests, testValidInputRangeValidInputRangeMax) ::ad::physics::Duration elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -227,14 +227,14 @@ TEST(SituationVectorValidInputRangeTests, testValidInputRangeValidInputRangeMax) ::ad::physics::Duration elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -376,14 +376,14 @@ TEST(SituationVectorValidInputRangeTests, testValidInputRangeHigherThanInputRang ::ad::physics::Duration elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -500,14 +500,14 @@ TEST(SituationVectorValidInputRangeTests, testValidInputRangeHigherThanInputRang ::ad::physics::Duration elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -659,14 +659,14 @@ TEST(SituationVectorValidInputRangeTests, testValidInputRangeElementValid) ::ad::physics::Duration elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t elementEgoVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; elementEgoVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -783,14 +783,14 @@ TEST(SituationVectorValidInputRangeTests, testValidInputRangeElementValid) ::ad::physics::Duration elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t elementOtherVehicleStateDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; elementOtherVehicleStateDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps diff --git a/ad_rss/impl/test/generated/ad/rss/situation/VehicleStateTests.cpp b/ad_rss/impl/test/generated/ad/rss/situation/VehicleStateTests.cpp index 849228dcab..f859b8ec48 100644 --- a/ad_rss/impl/test/generated/ad/rss/situation/VehicleStateTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/situation/VehicleStateTests.cpp @@ -91,12 +91,14 @@ class VehicleStateTests : public testing::Test ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -105,6 +107,30 @@ class VehicleStateTests : public testing::Test std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDynamics.unstructuredSettings = valueDynamicsUnstructuredSettings; value.dynamics = valueDynamics; bool valueHasPriority{true}; @@ -267,12 +293,14 @@ TEST_F(VehicleStateTests, comparisonOperatorDynamicsDiffers) ::ad::physics::Duration dynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(1e6); dynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = dynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t dynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::max()}; - dynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = dynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t dynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::max()}; - dynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = dynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t dynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + dynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = dynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t dynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + dynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = dynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t dynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::max()}; dynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = dynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -280,6 +308,30 @@ TEST_F(VehicleStateTests, comparisonOperatorDynamicsDiffers) std::numeric_limits::max()}; dynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = dynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t dynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + dynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = dynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t dynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + dynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = dynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t dynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + dynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = dynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t dynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + dynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = dynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t dynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + dynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = dynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t dynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + dynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = dynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; dynamics.unstructuredSettings = dynamicsUnstructuredSettings; valueA.dynamics = dynamics; ::ad::rss::situation::VehicleState valueB = mValue; diff --git a/ad_rss/impl/test/generated/ad/rss/situation/VehicleStateValidInputRangeTests.cpp b/ad_rss/impl/test/generated/ad/rss/situation/VehicleStateValidInputRangeTests.cpp index b046cb1c58..0523d48212 100644 --- a/ad_rss/impl/test/generated/ad/rss/situation/VehicleStateValidInputRangeTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/situation/VehicleStateValidInputRangeTests.cpp @@ -83,12 +83,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRange) ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -202,12 +204,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRangeVelocityTooSmall) ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -329,12 +333,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRangeVelocityTooBig) ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -456,12 +462,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRangeDynamicsTooSmall) ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -583,12 +591,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRangeDynamicsTooBig) ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -710,12 +720,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRangeDistanceToEnterInterse ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -839,12 +851,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRangeDistanceToEnterInterse ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -970,12 +984,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRangeDistanceToLeaveInterse ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1093,12 +1109,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRangeDistanceToLeaveInterse ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1229,12 +1247,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRangeObjectTypeTooSmall) ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1352,12 +1372,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRangeObjectTypeTooBig) ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1475,12 +1497,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRangeObjectStateTooSmall) ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1600,12 +1624,14 @@ TEST(VehicleStateValidInputRangeTests, testValidInputRangeObjectStateTooBig) ::ad::physics::Duration valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps diff --git a/ad_rss/impl/test/generated/ad/rss/state/RssStateSnapshotTests.cpp b/ad_rss/impl/test/generated/ad/rss/state/RssStateSnapshotTests.cpp index f496cb5162..0dde1007ae 100644 --- a/ad_rss/impl/test/generated/ad/rss/state/RssStateSnapshotTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/state/RssStateSnapshotTests.cpp @@ -84,14 +84,14 @@ class RssStateSnapshotTests : public testing::Test ::ad::physics::Duration valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -100,6 +100,33 @@ class RssStateSnapshotTests : public testing::Test std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDefaultEgoVehicleRssDynamics.unstructuredSettings = valueDefaultEgoVehicleRssDynamicsUnstructuredSettings; value.defaultEgoVehicleRssDynamics = valueDefaultEgoVehicleRssDynamics; ::ad::rss::state::RssStateVector valueIndividualResponses; @@ -445,14 +472,14 @@ TEST_F(RssStateSnapshotTests, comparisonOperatorDefaultEgoVehicleRssDynamicsDiff ::ad::physics::Duration defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(1e6); defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::max()}; defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -461,6 +488,30 @@ TEST_F(RssStateSnapshotTests, comparisonOperatorDefaultEgoVehicleRssDynamicsDiff std::numeric_limits::max()}; defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; defaultEgoVehicleRssDynamics.unstructuredSettings = defaultEgoVehicleRssDynamicsUnstructuredSettings; valueA.defaultEgoVehicleRssDynamics = defaultEgoVehicleRssDynamics; ::ad::rss::state::RssStateSnapshot valueB = mValue; diff --git a/ad_rss/impl/test/generated/ad/rss/state/RssStateSnapshotValidInputRangeTests.cpp b/ad_rss/impl/test/generated/ad/rss/state/RssStateSnapshotValidInputRangeTests.cpp index cdf06d576a..197cf324e3 100644 --- a/ad_rss/impl/test/generated/ad/rss/state/RssStateSnapshotValidInputRangeTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/state/RssStateSnapshotValidInputRangeTests.cpp @@ -76,14 +76,14 @@ TEST(RssStateSnapshotValidInputRangeTests, testValidInputRange) ::ad::physics::Duration valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -92,6 +92,32 @@ TEST(RssStateSnapshotValidInputRangeTests, testValidInputRange) std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDefaultEgoVehicleRssDynamics.unstructuredSettings = valueDefaultEgoVehicleRssDynamicsUnstructuredSettings; value.defaultEgoVehicleRssDynamics = valueDefaultEgoVehicleRssDynamics; ::ad::rss::state::RssStateVector valueIndividualResponses; @@ -376,14 +402,14 @@ TEST(RssStateSnapshotValidInputRangeTests, testValidInputRangeDefaultEgoVehicleR ::ad::physics::Duration valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -392,6 +418,32 @@ TEST(RssStateSnapshotValidInputRangeTests, testValidInputRangeDefaultEgoVehicleR std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDefaultEgoVehicleRssDynamics.unstructuredSettings = valueDefaultEgoVehicleRssDynamicsUnstructuredSettings; value.defaultEgoVehicleRssDynamics = valueDefaultEgoVehicleRssDynamics; ::ad::rss::state::RssStateVector valueIndividualResponses; @@ -684,14 +736,14 @@ TEST(RssStateSnapshotValidInputRangeTests, testValidInputRangeDefaultEgoVehicleR ::ad::physics::Duration valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -700,6 +752,32 @@ TEST(RssStateSnapshotValidInputRangeTests, testValidInputRangeDefaultEgoVehicleR std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDefaultEgoVehicleRssDynamics.unstructuredSettings = valueDefaultEgoVehicleRssDynamicsUnstructuredSettings; value.defaultEgoVehicleRssDynamics = valueDefaultEgoVehicleRssDynamics; ::ad::rss::state::RssStateVector valueIndividualResponses; diff --git a/ad_rss/impl/test/generated/ad/rss/world/RssDynamicsTests.cpp b/ad_rss/impl/test/generated/ad/rss/world/RssDynamicsTests.cpp index 4c805cf822..772d01009d 100644 --- a/ad_rss/impl/test/generated/ad/rss/world/RssDynamicsTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/world/RssDynamicsTests.cpp @@ -71,12 +71,14 @@ class RssDynamicsTests : public testing::Test ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -84,6 +86,30 @@ class RssDynamicsTests : public testing::Test std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; mValue = value; } @@ -224,10 +250,12 @@ TEST_F(RssDynamicsTests, comparisonOperatorUnstructuredSettingsDiffers) unstructuredSettings.vehicleMinRadius = unstructuredSettingsVehicleMinRadius; ::ad::physics::Duration unstructuredSettingsVehicleTrajectoryCalculationStep(1e6); unstructuredSettings.vehicleTrajectoryCalculationStep = unstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t unstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::max()}; - unstructuredSettings.vehicleFrontIntermediateRatioSteps = unstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t unstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::max()}; - unstructuredSettings.vehicleBackIntermediateRatioSteps = unstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t unstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::max()}; + unstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = unstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t unstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::max()}; + unstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = unstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t unstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::max()}; unstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = unstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -235,6 +263,27 @@ TEST_F(RssDynamicsTests, comparisonOperatorUnstructuredSettingsDiffers) std::numeric_limits::max()}; unstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = unstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t unstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + unstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = unstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t unstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + unstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = unstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t unstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + unstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = unstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t unstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::max()}; + unstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = unstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t unstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::max()}; + unstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = unstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t unstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::max()}; + unstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = unstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueA.unstructuredSettings = unstructuredSettings; ::ad::rss::world::RssDynamics valueB = mValue; diff --git a/ad_rss/impl/test/generated/ad/rss/world/RssDynamicsValidInputRangeTests.cpp b/ad_rss/impl/test/generated/ad/rss/world/RssDynamicsValidInputRangeTests.cpp index 7e79879bf9..ffb39c753e 100644 --- a/ad_rss/impl/test/generated/ad/rss/world/RssDynamicsValidInputRangeTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/world/RssDynamicsValidInputRangeTests.cpp @@ -64,12 +64,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRange) ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -77,6 +79,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRange) std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; ASSERT_TRUE(withinValidInputRange(value)); } @@ -127,12 +152,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeAlphaLonTooSmall) ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -140,6 +167,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeAlphaLonTooSmall) std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; // override member with data type value below input range minimum @@ -196,12 +246,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeAlphaLonTooBig) ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -209,6 +261,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeAlphaLonTooBig) std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; // override member with data type value above input range maximum @@ -265,12 +340,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeAlphaLatTooSmall) ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -278,6 +355,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeAlphaLatTooSmall) std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; // override member with data type value below input range minimum @@ -334,12 +434,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeAlphaLatTooBig) ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -347,6 +449,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeAlphaLatTooBig) std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; // override member with data type value above input range maximum @@ -403,12 +528,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeLateralFluctuationMargi ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -416,6 +543,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeLateralFluctuationMargi std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; // override member with data type value below input range minimum @@ -476,12 +626,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeLateralFluctuationMargi ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -489,6 +641,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeLateralFluctuationMargi std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; // override member with data type value above input range maximum @@ -556,12 +731,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeResponseTimeTooSmall) ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -569,6 +746,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeResponseTimeTooSmall) std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; // override member with data type value below input range minimum @@ -628,12 +828,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeResponseTimeTooBig) ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -641,6 +843,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeResponseTimeTooBig) std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; // override member with data type value above input range maximum @@ -708,12 +933,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeMaxSpeedOnAccelerationT ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -721,6 +948,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeMaxSpeedOnAccelerationT std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; // override member with data type value below input range minimum @@ -775,12 +1025,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeMaxSpeedOnAccelerationT ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -788,6 +1040,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeMaxSpeedOnAccelerationT std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; // override member with data type value above input range maximum @@ -850,12 +1125,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeUnstructuredSettingsToo ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -863,6 +1140,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeUnstructuredSettingsToo std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; // override member with data type value below input range minimum @@ -919,12 +1219,14 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeUnstructuredSettingsToo ::ad::physics::Duration valueUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueUnstructuredSettings.vehicleTrajectoryCalculationStep = valueUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - valueUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueUnstructuredSettingsVehicleBackIntermediateRatioSteps; + uint32_t valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; valueUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps; @@ -932,6 +1234,29 @@ TEST(RssDynamicsValidInputRangeTests, testValidInputRangeUnstructuredSettingsToo std::numeric_limits::min()}; valueUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; value.unstructuredSettings = valueUnstructuredSettings; // override member with data type value above input range maximum diff --git a/ad_rss/impl/test/generated/ad/rss/world/SceneTests.cpp b/ad_rss/impl/test/generated/ad/rss/world/SceneTests.cpp index 0374b5f245..73cd0939a0 100644 --- a/ad_rss/impl/test/generated/ad/rss/world/SceneTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/world/SceneTests.cpp @@ -145,14 +145,14 @@ class SceneTests : public testing::Test ::ad::physics::Duration valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -161,6 +161,30 @@ class SceneTests : public testing::Test std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleRssDynamics.unstructuredSettings = valueEgoVehicleRssDynamicsUnstructuredSettings; value.egoVehicleRssDynamics = valueEgoVehicleRssDynamics; ::ad::rss::world::Object valueObject; @@ -277,14 +301,14 @@ class SceneTests : public testing::Test ::ad::physics::Duration valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -293,6 +317,30 @@ class SceneTests : public testing::Test std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueObjectRssDynamics.unstructuredSettings = valueObjectRssDynamicsUnstructuredSettings; value.objectRssDynamics = valueObjectRssDynamics; ::ad::rss::world::RoadArea valueIntersectingRoad; @@ -548,14 +596,14 @@ TEST_F(SceneTests, comparisonOperatorEgoVehicleRssDynamicsDiffers) ::ad::physics::Duration egoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(1e6); egoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = egoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t egoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t egoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - egoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = egoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t egoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + egoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = egoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t egoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - egoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = egoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + egoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = egoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t egoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::max()}; egoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -564,6 +612,30 @@ TEST_F(SceneTests, comparisonOperatorEgoVehicleRssDynamicsDiffers) std::numeric_limits::max()}; egoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = egoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t egoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + egoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = egoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t egoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + egoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = egoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t egoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + egoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = egoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t egoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + egoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = egoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t egoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + egoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = egoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t egoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + egoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = egoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; egoVehicleRssDynamics.unstructuredSettings = egoVehicleRssDynamicsUnstructuredSettings; valueA.egoVehicleRssDynamics = egoVehicleRssDynamics; ::ad::rss::world::Scene valueB = mValue; @@ -694,13 +766,14 @@ TEST_F(SceneTests, comparisonOperatorObjectRssDynamicsDiffers) ::ad::physics::Duration objectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(1e6); objectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = objectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t objectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t objectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + objectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = objectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t objectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - objectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = objectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t objectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{std::numeric_limits::max()}; - objectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = objectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + objectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = objectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t objectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::max()}; objectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -709,6 +782,30 @@ TEST_F(SceneTests, comparisonOperatorObjectRssDynamicsDiffers) std::numeric_limits::max()}; objectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = objectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t objectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + objectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = objectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t objectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + objectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = objectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t objectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + objectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = objectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t objectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + objectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = objectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t objectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + objectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = objectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t objectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + objectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = objectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; objectRssDynamics.unstructuredSettings = objectRssDynamicsUnstructuredSettings; valueA.objectRssDynamics = objectRssDynamics; ::ad::rss::world::Scene valueB = mValue; diff --git a/ad_rss/impl/test/generated/ad/rss/world/SceneValidInputRangeTests.cpp b/ad_rss/impl/test/generated/ad/rss/world/SceneValidInputRangeTests.cpp index c87c38e374..f2e3dbcbf9 100644 --- a/ad_rss/impl/test/generated/ad/rss/world/SceneValidInputRangeTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/world/SceneValidInputRangeTests.cpp @@ -137,14 +137,14 @@ TEST(SceneValidInputRangeTests, testValidInputRange) ::ad::physics::Duration valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -153,6 +153,30 @@ TEST(SceneValidInputRangeTests, testValidInputRange) std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleRssDynamics.unstructuredSettings = valueEgoVehicleRssDynamicsUnstructuredSettings; value.egoVehicleRssDynamics = valueEgoVehicleRssDynamics; ::ad::rss::world::Object valueObject; @@ -269,14 +293,14 @@ TEST(SceneValidInputRangeTests, testValidInputRange) ::ad::physics::Duration valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -285,6 +309,30 @@ TEST(SceneValidInputRangeTests, testValidInputRange) std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueObjectRssDynamics.unstructuredSettings = valueObjectRssDynamicsUnstructuredSettings; value.objectRssDynamics = valueObjectRssDynamics; ::ad::rss::world::RoadArea valueIntersectingRoad; @@ -473,14 +521,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeSituationTypeTooSmall) ::ad::physics::Duration valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -489,6 +537,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeSituationTypeTooSmall) std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleRssDynamics.unstructuredSettings = valueEgoVehicleRssDynamicsUnstructuredSettings; value.egoVehicleRssDynamics = valueEgoVehicleRssDynamics; ::ad::rss::world::Object valueObject; @@ -605,14 +677,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeSituationTypeTooSmall) ::ad::physics::Duration valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -621,6 +693,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeSituationTypeTooSmall) std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueObjectRssDynamics.unstructuredSettings = valueObjectRssDynamicsUnstructuredSettings; value.objectRssDynamics = valueObjectRssDynamics; ::ad::rss::world::RoadArea valueIntersectingRoad; @@ -813,14 +909,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeSituationTypeTooBig) ::ad::physics::Duration valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -829,6 +925,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeSituationTypeTooBig) std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleRssDynamics.unstructuredSettings = valueEgoVehicleRssDynamicsUnstructuredSettings; value.egoVehicleRssDynamics = valueEgoVehicleRssDynamics; ::ad::rss::world::Object valueObject; @@ -945,14 +1065,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeSituationTypeTooBig) ::ad::physics::Duration valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -961,6 +1081,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeSituationTypeTooBig) std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueObjectRssDynamics.unstructuredSettings = valueObjectRssDynamicsUnstructuredSettings; value.objectRssDynamics = valueObjectRssDynamics; ::ad::rss::world::RoadArea valueIntersectingRoad; @@ -1153,14 +1297,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleTooSmall) ::ad::physics::Duration valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1169,6 +1313,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleTooSmall) std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleRssDynamics.unstructuredSettings = valueEgoVehicleRssDynamicsUnstructuredSettings; value.egoVehicleRssDynamics = valueEgoVehicleRssDynamics; ::ad::rss::world::Object valueObject; @@ -1285,14 +1453,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleTooSmall) ::ad::physics::Duration valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1301,6 +1469,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleTooSmall) std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueObjectRssDynamics.unstructuredSettings = valueObjectRssDynamicsUnstructuredSettings; value.objectRssDynamics = valueObjectRssDynamics; ::ad::rss::world::RoadArea valueIntersectingRoad; @@ -1495,14 +1687,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleTooBig) ::ad::physics::Duration valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1511,6 +1703,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleTooBig) std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleRssDynamics.unstructuredSettings = valueEgoVehicleRssDynamicsUnstructuredSettings; value.egoVehicleRssDynamics = valueEgoVehicleRssDynamics; ::ad::rss::world::Object valueObject; @@ -1627,14 +1843,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleTooBig) ::ad::physics::Duration valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1643,6 +1859,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleTooBig) std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueObjectRssDynamics.unstructuredSettings = valueObjectRssDynamicsUnstructuredSettings; value.objectRssDynamics = valueObjectRssDynamics; ::ad::rss::world::RoadArea valueIntersectingRoad; @@ -1837,14 +2077,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleRssDynamicsTooSmall ::ad::physics::Duration valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1853,6 +2093,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleRssDynamicsTooSmall std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleRssDynamics.unstructuredSettings = valueEgoVehicleRssDynamicsUnstructuredSettings; value.egoVehicleRssDynamics = valueEgoVehicleRssDynamics; ::ad::rss::world::Object valueObject; @@ -1969,14 +2233,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleRssDynamicsTooSmall ::ad::physics::Duration valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1985,6 +2249,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleRssDynamicsTooSmall std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueObjectRssDynamics.unstructuredSettings = valueObjectRssDynamicsUnstructuredSettings; value.objectRssDynamics = valueObjectRssDynamics; ::ad::rss::world::RoadArea valueIntersectingRoad; @@ -2181,14 +2469,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleRssDynamicsTooBig) ::ad::physics::Duration valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -2197,6 +2485,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleRssDynamicsTooBig) std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleRssDynamics.unstructuredSettings = valueEgoVehicleRssDynamicsUnstructuredSettings; value.egoVehicleRssDynamics = valueEgoVehicleRssDynamics; ::ad::rss::world::Object valueObject; @@ -2313,14 +2625,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleRssDynamicsTooBig) ::ad::physics::Duration valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -2329,6 +2641,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeEgoVehicleRssDynamicsTooBig) std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueObjectRssDynamics.unstructuredSettings = valueObjectRssDynamicsUnstructuredSettings; value.objectRssDynamics = valueObjectRssDynamics; ::ad::rss::world::RoadArea valueIntersectingRoad; @@ -2525,14 +2861,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectTooSmall) ::ad::physics::Duration valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -2541,6 +2877,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectTooSmall) std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleRssDynamics.unstructuredSettings = valueEgoVehicleRssDynamicsUnstructuredSettings; value.egoVehicleRssDynamics = valueEgoVehicleRssDynamics; ::ad::rss::world::Object valueObject; @@ -2657,14 +3017,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectTooSmall) ::ad::physics::Duration valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -2673,6 +3033,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectTooSmall) std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueObjectRssDynamics.unstructuredSettings = valueObjectRssDynamicsUnstructuredSettings; value.objectRssDynamics = valueObjectRssDynamics; ::ad::rss::world::RoadArea valueIntersectingRoad; @@ -2867,14 +3251,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectTooBig) ::ad::physics::Duration valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -2883,6 +3267,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectTooBig) std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleRssDynamics.unstructuredSettings = valueEgoVehicleRssDynamicsUnstructuredSettings; value.egoVehicleRssDynamics = valueEgoVehicleRssDynamics; ::ad::rss::world::Object valueObject; @@ -2999,14 +3407,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectTooBig) ::ad::physics::Duration valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -3015,6 +3423,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectTooBig) std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueObjectRssDynamics.unstructuredSettings = valueObjectRssDynamicsUnstructuredSettings; value.objectRssDynamics = valueObjectRssDynamics; ::ad::rss::world::RoadArea valueIntersectingRoad; @@ -3209,14 +3641,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectRssDynamicsTooSmall) ::ad::physics::Duration valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -3225,6 +3657,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectRssDynamicsTooSmall) std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleRssDynamics.unstructuredSettings = valueEgoVehicleRssDynamicsUnstructuredSettings; value.egoVehicleRssDynamics = valueEgoVehicleRssDynamics; ::ad::rss::world::Object valueObject; @@ -3341,14 +3797,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectRssDynamicsTooSmall) ::ad::physics::Duration valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -3357,6 +3813,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectRssDynamicsTooSmall) std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueObjectRssDynamics.unstructuredSettings = valueObjectRssDynamicsUnstructuredSettings; value.objectRssDynamics = valueObjectRssDynamics; ::ad::rss::world::RoadArea valueIntersectingRoad; @@ -3553,14 +4033,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectRssDynamicsTooBig) ::ad::physics::Duration valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -3569,6 +4049,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectRssDynamicsTooBig) std::numeric_limits::min()}; valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueEgoVehicleRssDynamics.unstructuredSettings = valueEgoVehicleRssDynamicsUnstructuredSettings; value.egoVehicleRssDynamics = valueEgoVehicleRssDynamics; ::ad::rss::world::Object valueObject; @@ -3685,14 +4189,14 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectRssDynamicsTooBig) ::ad::physics::Duration valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -3701,6 +4205,30 @@ TEST(SceneValidInputRangeTests, testValidInputRangeObjectRssDynamicsTooBig) std::numeric_limits::min()}; valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueObjectRssDynamics.unstructuredSettings = valueObjectRssDynamicsUnstructuredSettings; value.objectRssDynamics = valueObjectRssDynamics; ::ad::rss::world::RoadArea valueIntersectingRoad; diff --git a/ad_rss/impl/test/generated/ad/rss/world/SceneVectorValidInputRangeTests.cpp b/ad_rss/impl/test/generated/ad/rss/world/SceneVectorValidInputRangeTests.cpp index 7266762ffc..189ba55358 100644 --- a/ad_rss/impl/test/generated/ad/rss/world/SceneVectorValidInputRangeTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/world/SceneVectorValidInputRangeTests.cpp @@ -145,14 +145,14 @@ TEST(SceneVectorValidInputRangeTests, testValidInputRangeValidInputRangeMax) ::ad::physics::Duration elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -161,6 +161,30 @@ TEST(SceneVectorValidInputRangeTests, testValidInputRangeValidInputRangeMax) std::numeric_limits::min()}; elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; elementEgoVehicleRssDynamics.unstructuredSettings = elementEgoVehicleRssDynamicsUnstructuredSettings; element.egoVehicleRssDynamics = elementEgoVehicleRssDynamics; ::ad::rss::world::Object elementObject; @@ -277,14 +301,14 @@ TEST(SceneVectorValidInputRangeTests, testValidInputRangeValidInputRangeMax) ::ad::physics::Duration elementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); elementObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = elementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = elementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + elementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = elementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + elementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; elementObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -293,6 +317,30 @@ TEST(SceneVectorValidInputRangeTests, testValidInputRangeValidInputRangeMax) std::numeric_limits::min()}; elementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = elementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; elementObjectRssDynamics.unstructuredSettings = elementObjectRssDynamicsUnstructuredSettings; element.objectRssDynamics = elementObjectRssDynamics; ::ad::rss::world::RoadArea elementIntersectingRoad; @@ -485,14 +533,14 @@ TEST(SceneVectorValidInputRangeTests, testValidInputRangeHigherThanInputRangeMax ::ad::physics::Duration elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -501,6 +549,30 @@ TEST(SceneVectorValidInputRangeTests, testValidInputRangeHigherThanInputRangeMax std::numeric_limits::min()}; elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; elementEgoVehicleRssDynamics.unstructuredSettings = elementEgoVehicleRssDynamicsUnstructuredSettings; element.egoVehicleRssDynamics = elementEgoVehicleRssDynamics; ::ad::rss::world::Object elementObject; @@ -617,14 +689,14 @@ TEST(SceneVectorValidInputRangeTests, testValidInputRangeHigherThanInputRangeMax ::ad::physics::Duration elementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); elementObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = elementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = elementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + elementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = elementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + elementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; elementObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -633,6 +705,30 @@ TEST(SceneVectorValidInputRangeTests, testValidInputRangeHigherThanInputRangeMax std::numeric_limits::min()}; elementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = elementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; elementObjectRssDynamics.unstructuredSettings = elementObjectRssDynamicsUnstructuredSettings; element.objectRssDynamics = elementObjectRssDynamics; ::ad::rss::world::RoadArea elementIntersectingRoad; @@ -835,14 +931,14 @@ TEST(SceneVectorValidInputRangeTests, testValidInputRangeElementValid) ::ad::physics::Duration elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -851,6 +947,30 @@ TEST(SceneVectorValidInputRangeTests, testValidInputRangeElementValid) std::numeric_limits::min()}; elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = elementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; elementEgoVehicleRssDynamics.unstructuredSettings = elementEgoVehicleRssDynamicsUnstructuredSettings; element.egoVehicleRssDynamics = elementEgoVehicleRssDynamics; ::ad::rss::world::Object elementObject; @@ -967,14 +1087,14 @@ TEST(SceneVectorValidInputRangeTests, testValidInputRangeElementValid) ::ad::physics::Duration elementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); elementObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = elementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = elementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + elementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - elementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = elementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + elementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; elementObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -983,6 +1103,30 @@ TEST(SceneVectorValidInputRangeTests, testValidInputRangeElementValid) std::numeric_limits::min()}; elementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = elementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t elementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + elementObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = elementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; elementObjectRssDynamics.unstructuredSettings = elementObjectRssDynamicsUnstructuredSettings; element.objectRssDynamics = elementObjectRssDynamics; ::ad::rss::world::RoadArea elementIntersectingRoad; diff --git a/ad_rss/impl/test/generated/ad/rss/world/UnstructuredSettingsTests.cpp b/ad_rss/impl/test/generated/ad/rss/world/UnstructuredSettingsTests.cpp index bd7e4e07b5..0b605deb99 100644 --- a/ad_rss/impl/test/generated/ad/rss/world/UnstructuredSettingsTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/world/UnstructuredSettingsTests.cpp @@ -38,15 +38,30 @@ class UnstructuredSettingsTests : public testing::Test value.vehicleMinRadius = valueVehicleMinRadius; ::ad::physics::Duration valueVehicleTrajectoryCalculationStep(0.); value.vehicleTrajectoryCalculationStep = valueVehicleTrajectoryCalculationStep; - uint32_t valueVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleFrontIntermediateRatioSteps = valueVehicleFrontIntermediateRatioSteps; - uint32_t valueVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleBackIntermediateRatioSteps = valueVehicleBackIntermediateRatioSteps; + uint32_t valueVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleFrontIntermediateYawRateChangeRatioSteps = valueVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleBackIntermediateYawRateChangeRatioSteps = valueVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleBrakeIntermediateAccelerationSteps = valueVehicleBrakeIntermediateAccelerationSteps; uint32_t valueVehicleContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleContinueForwardIntermediateAccelerationSteps = valueVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateAccelerationSteps + = valuePedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valuePedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianBrakeIntermediateAccelerationSteps = valuePedestrianBrakeIntermediateAccelerationSteps; + uint32_t valuePedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianFrontIntermediateHeadingChangeRatioSteps = valuePedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianBackIntermediateHeadingChangeRatioSteps = valuePedestrianBackIntermediateHeadingChangeRatioSteps; mValue = value; } @@ -154,22 +169,22 @@ TEST_F(UnstructuredSettingsTests, comparisonOperatorVehicleTrajectoryCalculation EXPECT_TRUE(valueA != valueB); } -TEST_F(UnstructuredSettingsTests, comparisonOperatorVehicleFrontIntermediateRatioStepsDiffers) +TEST_F(UnstructuredSettingsTests, comparisonOperatorVehicleFrontIntermediateYawRateChangeRatioStepsDiffers) { ::ad::rss::world::UnstructuredSettings valueA = mValue; - uint32_t vehicleFrontIntermediateRatioSteps{std::numeric_limits::max()}; - valueA.vehicleFrontIntermediateRatioSteps = vehicleFrontIntermediateRatioSteps; + uint32_t vehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::max()}; + valueA.vehicleFrontIntermediateYawRateChangeRatioSteps = vehicleFrontIntermediateYawRateChangeRatioSteps; ::ad::rss::world::UnstructuredSettings valueB = mValue; EXPECT_FALSE(valueA == valueB); EXPECT_TRUE(valueA != valueB); } -TEST_F(UnstructuredSettingsTests, comparisonOperatorVehicleBackIntermediateRatioStepsDiffers) +TEST_F(UnstructuredSettingsTests, comparisonOperatorVehicleBackIntermediateYawRateChangeRatioStepsDiffers) { ::ad::rss::world::UnstructuredSettings valueA = mValue; - uint32_t vehicleBackIntermediateRatioSteps{std::numeric_limits::max()}; - valueA.vehicleBackIntermediateRatioSteps = vehicleBackIntermediateRatioSteps; + uint32_t vehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::max()}; + valueA.vehicleBackIntermediateYawRateChangeRatioSteps = vehicleBackIntermediateYawRateChangeRatioSteps; ::ad::rss::world::UnstructuredSettings valueB = mValue; EXPECT_FALSE(valueA == valueB); @@ -198,6 +213,75 @@ TEST_F(UnstructuredSettingsTests, comparisonOperatorVehicleContinueForwardInterm EXPECT_TRUE(valueA != valueB); } +TEST_F(UnstructuredSettingsTests, comparisonOperatorVehicleContinueForwardIntermediateYawRateChangeRatioStepsDiffers) +{ + ::ad::rss::world::UnstructuredSettings valueA = mValue; + uint32_t vehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::max()}; + valueA.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = vehicleContinueForwardIntermediateYawRateChangeRatioSteps; + ::ad::rss::world::UnstructuredSettings valueB = mValue; + + EXPECT_FALSE(valueA == valueB); + EXPECT_TRUE(valueA != valueB); +} + +TEST_F(UnstructuredSettingsTests, comparisonOperatorPedestrianContinueForwardIntermediateHeadingChangeRatioStepsDiffers) +{ + ::ad::rss::world::UnstructuredSettings valueA = mValue; + uint32_t pedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::max()}; + valueA.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = pedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + ::ad::rss::world::UnstructuredSettings valueB = mValue; + + EXPECT_FALSE(valueA == valueB); + EXPECT_TRUE(valueA != valueB); +} + +TEST_F(UnstructuredSettingsTests, comparisonOperatorPedestrianContinueForwardIntermediateAccelerationStepsDiffers) +{ + ::ad::rss::world::UnstructuredSettings valueA = mValue; + uint32_t pedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::max()}; + valueA.pedestrianContinueForwardIntermediateAccelerationSteps + = pedestrianContinueForwardIntermediateAccelerationSteps; + ::ad::rss::world::UnstructuredSettings valueB = mValue; + + EXPECT_FALSE(valueA == valueB); + EXPECT_TRUE(valueA != valueB); +} + +TEST_F(UnstructuredSettingsTests, comparisonOperatorPedestrianBrakeIntermediateAccelerationStepsDiffers) +{ + ::ad::rss::world::UnstructuredSettings valueA = mValue; + uint32_t pedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::max()}; + valueA.pedestrianBrakeIntermediateAccelerationSteps = pedestrianBrakeIntermediateAccelerationSteps; + ::ad::rss::world::UnstructuredSettings valueB = mValue; + + EXPECT_FALSE(valueA == valueB); + EXPECT_TRUE(valueA != valueB); +} + +TEST_F(UnstructuredSettingsTests, comparisonOperatorPedestrianFrontIntermediateHeadingChangeRatioStepsDiffers) +{ + ::ad::rss::world::UnstructuredSettings valueA = mValue; + uint32_t pedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::max()}; + valueA.pedestrianFrontIntermediateHeadingChangeRatioSteps = pedestrianFrontIntermediateHeadingChangeRatioSteps; + ::ad::rss::world::UnstructuredSettings valueB = mValue; + + EXPECT_FALSE(valueA == valueB); + EXPECT_TRUE(valueA != valueB); +} + +TEST_F(UnstructuredSettingsTests, comparisonOperatorPedestrianBackIntermediateHeadingChangeRatioStepsDiffers) +{ + ::ad::rss::world::UnstructuredSettings valueA = mValue; + uint32_t pedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::max()}; + valueA.pedestrianBackIntermediateHeadingChangeRatioSteps = pedestrianBackIntermediateHeadingChangeRatioSteps; + ::ad::rss::world::UnstructuredSettings valueB = mValue; + + EXPECT_FALSE(valueA == valueB); + EXPECT_TRUE(valueA != valueB); +} + #if defined(__clang__) && (__clang_major__ >= 7) #pragma GCC diagnostic pop #endif diff --git a/ad_rss/impl/test/generated/ad/rss/world/UnstructuredSettingsValidInputRangeTests.cpp b/ad_rss/impl/test/generated/ad/rss/world/UnstructuredSettingsValidInputRangeTests.cpp index ddf69062f1..a499e40ea3 100644 --- a/ad_rss/impl/test/generated/ad/rss/world/UnstructuredSettingsValidInputRangeTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/world/UnstructuredSettingsValidInputRangeTests.cpp @@ -31,14 +31,29 @@ TEST(UnstructuredSettingsValidInputRangeTests, testValidInputRange) value.vehicleMinRadius = valueVehicleMinRadius; ::ad::physics::Duration valueVehicleTrajectoryCalculationStep(0.); value.vehicleTrajectoryCalculationStep = valueVehicleTrajectoryCalculationStep; - uint32_t valueVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleFrontIntermediateRatioSteps = valueVehicleFrontIntermediateRatioSteps; - uint32_t valueVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleBackIntermediateRatioSteps = valueVehicleBackIntermediateRatioSteps; + uint32_t valueVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleFrontIntermediateYawRateChangeRatioSteps = valueVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleBackIntermediateYawRateChangeRatioSteps = valueVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleBrakeIntermediateAccelerationSteps = valueVehicleBrakeIntermediateAccelerationSteps; uint32_t valueVehicleContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleContinueForwardIntermediateAccelerationSteps = valueVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateAccelerationSteps + = valuePedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valuePedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianBrakeIntermediateAccelerationSteps = valuePedestrianBrakeIntermediateAccelerationSteps; + uint32_t valuePedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianFrontIntermediateHeadingChangeRatioSteps = valuePedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianBackIntermediateHeadingChangeRatioSteps = valuePedestrianBackIntermediateHeadingChangeRatioSteps; ASSERT_TRUE(withinValidInputRange(value)); } @@ -55,14 +70,29 @@ TEST(UnstructuredSettingsValidInputRangeTests, testValidInputRangePedestrianTurn value.vehicleMinRadius = valueVehicleMinRadius; ::ad::physics::Duration valueVehicleTrajectoryCalculationStep(0.); value.vehicleTrajectoryCalculationStep = valueVehicleTrajectoryCalculationStep; - uint32_t valueVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleFrontIntermediateRatioSteps = valueVehicleFrontIntermediateRatioSteps; - uint32_t valueVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleBackIntermediateRatioSteps = valueVehicleBackIntermediateRatioSteps; + uint32_t valueVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleFrontIntermediateYawRateChangeRatioSteps = valueVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleBackIntermediateYawRateChangeRatioSteps = valueVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleBrakeIntermediateAccelerationSteps = valueVehicleBrakeIntermediateAccelerationSteps; uint32_t valueVehicleContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleContinueForwardIntermediateAccelerationSteps = valueVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateAccelerationSteps + = valuePedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valuePedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianBrakeIntermediateAccelerationSteps = valuePedestrianBrakeIntermediateAccelerationSteps; + uint32_t valuePedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianFrontIntermediateHeadingChangeRatioSteps = valuePedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianBackIntermediateHeadingChangeRatioSteps = valuePedestrianBackIntermediateHeadingChangeRatioSteps; // override member with data type value below input range minimum ::ad::physics::Distance invalidInitializedMember(-1e9 * 1.1); @@ -83,14 +113,29 @@ TEST(UnstructuredSettingsValidInputRangeTests, testValidInputRangePedestrianTurn value.vehicleMinRadius = valueVehicleMinRadius; ::ad::physics::Duration valueVehicleTrajectoryCalculationStep(0.); value.vehicleTrajectoryCalculationStep = valueVehicleTrajectoryCalculationStep; - uint32_t valueVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleFrontIntermediateRatioSteps = valueVehicleFrontIntermediateRatioSteps; - uint32_t valueVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleBackIntermediateRatioSteps = valueVehicleBackIntermediateRatioSteps; + uint32_t valueVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleFrontIntermediateYawRateChangeRatioSteps = valueVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleBackIntermediateYawRateChangeRatioSteps = valueVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleBrakeIntermediateAccelerationSteps = valueVehicleBrakeIntermediateAccelerationSteps; uint32_t valueVehicleContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleContinueForwardIntermediateAccelerationSteps = valueVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateAccelerationSteps + = valuePedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valuePedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianBrakeIntermediateAccelerationSteps = valuePedestrianBrakeIntermediateAccelerationSteps; + uint32_t valuePedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianFrontIntermediateHeadingChangeRatioSteps = valuePedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianBackIntermediateHeadingChangeRatioSteps = valuePedestrianBackIntermediateHeadingChangeRatioSteps; // override member with data type value above input range maximum ::ad::physics::Distance invalidInitializedMember(1e9 * 1.1); @@ -119,14 +164,29 @@ TEST(UnstructuredSettingsValidInputRangeTests, testValidInputRangeDriveAwayMaxAn value.vehicleMinRadius = valueVehicleMinRadius; ::ad::physics::Duration valueVehicleTrajectoryCalculationStep(0.); value.vehicleTrajectoryCalculationStep = valueVehicleTrajectoryCalculationStep; - uint32_t valueVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleFrontIntermediateRatioSteps = valueVehicleFrontIntermediateRatioSteps; - uint32_t valueVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleBackIntermediateRatioSteps = valueVehicleBackIntermediateRatioSteps; + uint32_t valueVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleFrontIntermediateYawRateChangeRatioSteps = valueVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleBackIntermediateYawRateChangeRatioSteps = valueVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleBrakeIntermediateAccelerationSteps = valueVehicleBrakeIntermediateAccelerationSteps; uint32_t valueVehicleContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleContinueForwardIntermediateAccelerationSteps = valueVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateAccelerationSteps + = valuePedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valuePedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianBrakeIntermediateAccelerationSteps = valuePedestrianBrakeIntermediateAccelerationSteps; + uint32_t valuePedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianFrontIntermediateHeadingChangeRatioSteps = valuePedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianBackIntermediateHeadingChangeRatioSteps = valuePedestrianBackIntermediateHeadingChangeRatioSteps; // override member with data type value below input range minimum ::ad::physics::Angle invalidInitializedMember(-6.283185308 * 1.1); @@ -147,14 +207,29 @@ TEST(UnstructuredSettingsValidInputRangeTests, testValidInputRangeDriveAwayMaxAn value.vehicleMinRadius = valueVehicleMinRadius; ::ad::physics::Duration valueVehicleTrajectoryCalculationStep(0.); value.vehicleTrajectoryCalculationStep = valueVehicleTrajectoryCalculationStep; - uint32_t valueVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleFrontIntermediateRatioSteps = valueVehicleFrontIntermediateRatioSteps; - uint32_t valueVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleBackIntermediateRatioSteps = valueVehicleBackIntermediateRatioSteps; + uint32_t valueVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleFrontIntermediateYawRateChangeRatioSteps = valueVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleBackIntermediateYawRateChangeRatioSteps = valueVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleBrakeIntermediateAccelerationSteps = valueVehicleBrakeIntermediateAccelerationSteps; uint32_t valueVehicleContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleContinueForwardIntermediateAccelerationSteps = valueVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateAccelerationSteps + = valuePedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valuePedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianBrakeIntermediateAccelerationSteps = valuePedestrianBrakeIntermediateAccelerationSteps; + uint32_t valuePedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianFrontIntermediateHeadingChangeRatioSteps = valuePedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianBackIntermediateHeadingChangeRatioSteps = valuePedestrianBackIntermediateHeadingChangeRatioSteps; // override member with data type value above input range maximum ::ad::physics::Angle invalidInitializedMember(6.283185308 * 1.1); @@ -183,14 +258,29 @@ TEST(UnstructuredSettingsValidInputRangeTests, testValidInputRangeVehicleYawRate value.vehicleMinRadius = valueVehicleMinRadius; ::ad::physics::Duration valueVehicleTrajectoryCalculationStep(0.); value.vehicleTrajectoryCalculationStep = valueVehicleTrajectoryCalculationStep; - uint32_t valueVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleFrontIntermediateRatioSteps = valueVehicleFrontIntermediateRatioSteps; - uint32_t valueVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleBackIntermediateRatioSteps = valueVehicleBackIntermediateRatioSteps; + uint32_t valueVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleFrontIntermediateYawRateChangeRatioSteps = valueVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleBackIntermediateYawRateChangeRatioSteps = valueVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleBrakeIntermediateAccelerationSteps = valueVehicleBrakeIntermediateAccelerationSteps; uint32_t valueVehicleContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleContinueForwardIntermediateAccelerationSteps = valueVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateAccelerationSteps + = valuePedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valuePedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianBrakeIntermediateAccelerationSteps = valuePedestrianBrakeIntermediateAccelerationSteps; + uint32_t valuePedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianFrontIntermediateHeadingChangeRatioSteps = valuePedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianBackIntermediateHeadingChangeRatioSteps = valuePedestrianBackIntermediateHeadingChangeRatioSteps; // override member with data type value below input range minimum ::ad::physics::AngularAcceleration invalidInitializedMember(-1e2 * 1.1); @@ -211,14 +301,29 @@ TEST(UnstructuredSettingsValidInputRangeTests, testValidInputRangeVehicleYawRate value.vehicleMinRadius = valueVehicleMinRadius; ::ad::physics::Duration valueVehicleTrajectoryCalculationStep(0.); value.vehicleTrajectoryCalculationStep = valueVehicleTrajectoryCalculationStep; - uint32_t valueVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleFrontIntermediateRatioSteps = valueVehicleFrontIntermediateRatioSteps; - uint32_t valueVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleBackIntermediateRatioSteps = valueVehicleBackIntermediateRatioSteps; + uint32_t valueVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleFrontIntermediateYawRateChangeRatioSteps = valueVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleBackIntermediateYawRateChangeRatioSteps = valueVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleBrakeIntermediateAccelerationSteps = valueVehicleBrakeIntermediateAccelerationSteps; uint32_t valueVehicleContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleContinueForwardIntermediateAccelerationSteps = valueVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateAccelerationSteps + = valuePedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valuePedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianBrakeIntermediateAccelerationSteps = valuePedestrianBrakeIntermediateAccelerationSteps; + uint32_t valuePedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianFrontIntermediateHeadingChangeRatioSteps = valuePedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianBackIntermediateHeadingChangeRatioSteps = valuePedestrianBackIntermediateHeadingChangeRatioSteps; // override member with data type value above input range maximum ::ad::physics::AngularAcceleration invalidInitializedMember(1e2 * 1.1); @@ -247,14 +352,29 @@ TEST(UnstructuredSettingsValidInputRangeTests, testValidInputRangeVehicleMinRadi value.vehicleMinRadius = valueVehicleMinRadius; ::ad::physics::Duration valueVehicleTrajectoryCalculationStep(0.); value.vehicleTrajectoryCalculationStep = valueVehicleTrajectoryCalculationStep; - uint32_t valueVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleFrontIntermediateRatioSteps = valueVehicleFrontIntermediateRatioSteps; - uint32_t valueVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleBackIntermediateRatioSteps = valueVehicleBackIntermediateRatioSteps; + uint32_t valueVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleFrontIntermediateYawRateChangeRatioSteps = valueVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleBackIntermediateYawRateChangeRatioSteps = valueVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleBrakeIntermediateAccelerationSteps = valueVehicleBrakeIntermediateAccelerationSteps; uint32_t valueVehicleContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleContinueForwardIntermediateAccelerationSteps = valueVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateAccelerationSteps + = valuePedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valuePedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianBrakeIntermediateAccelerationSteps = valuePedestrianBrakeIntermediateAccelerationSteps; + uint32_t valuePedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianFrontIntermediateHeadingChangeRatioSteps = valuePedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianBackIntermediateHeadingChangeRatioSteps = valuePedestrianBackIntermediateHeadingChangeRatioSteps; // override member with data type value below input range minimum ::ad::physics::Distance invalidInitializedMember(-1e9 * 1.1); @@ -275,14 +395,29 @@ TEST(UnstructuredSettingsValidInputRangeTests, testValidInputRangeVehicleMinRadi value.vehicleMinRadius = valueVehicleMinRadius; ::ad::physics::Duration valueVehicleTrajectoryCalculationStep(0.); value.vehicleTrajectoryCalculationStep = valueVehicleTrajectoryCalculationStep; - uint32_t valueVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleFrontIntermediateRatioSteps = valueVehicleFrontIntermediateRatioSteps; - uint32_t valueVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleBackIntermediateRatioSteps = valueVehicleBackIntermediateRatioSteps; + uint32_t valueVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleFrontIntermediateYawRateChangeRatioSteps = valueVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleBackIntermediateYawRateChangeRatioSteps = valueVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleBrakeIntermediateAccelerationSteps = valueVehicleBrakeIntermediateAccelerationSteps; uint32_t valueVehicleContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleContinueForwardIntermediateAccelerationSteps = valueVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateAccelerationSteps + = valuePedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valuePedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianBrakeIntermediateAccelerationSteps = valuePedestrianBrakeIntermediateAccelerationSteps; + uint32_t valuePedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianFrontIntermediateHeadingChangeRatioSteps = valuePedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianBackIntermediateHeadingChangeRatioSteps = valuePedestrianBackIntermediateHeadingChangeRatioSteps; // override member with data type value above input range maximum ::ad::physics::Distance invalidInitializedMember(1e9 * 1.1); @@ -311,14 +446,29 @@ TEST(UnstructuredSettingsValidInputRangeTests, testValidInputRangeVehicleTraject value.vehicleMinRadius = valueVehicleMinRadius; ::ad::physics::Duration valueVehicleTrajectoryCalculationStep(0.); value.vehicleTrajectoryCalculationStep = valueVehicleTrajectoryCalculationStep; - uint32_t valueVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleFrontIntermediateRatioSteps = valueVehicleFrontIntermediateRatioSteps; - uint32_t valueVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleBackIntermediateRatioSteps = valueVehicleBackIntermediateRatioSteps; + uint32_t valueVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleFrontIntermediateYawRateChangeRatioSteps = valueVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleBackIntermediateYawRateChangeRatioSteps = valueVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleBrakeIntermediateAccelerationSteps = valueVehicleBrakeIntermediateAccelerationSteps; uint32_t valueVehicleContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleContinueForwardIntermediateAccelerationSteps = valueVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateAccelerationSteps + = valuePedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valuePedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianBrakeIntermediateAccelerationSteps = valuePedestrianBrakeIntermediateAccelerationSteps; + uint32_t valuePedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianFrontIntermediateHeadingChangeRatioSteps = valuePedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianBackIntermediateHeadingChangeRatioSteps = valuePedestrianBackIntermediateHeadingChangeRatioSteps; // override member with data type value below input range minimum ::ad::physics::Duration invalidInitializedMember(0. - ::ad::physics::Duration::cPrecisionValue); @@ -339,14 +489,29 @@ TEST(UnstructuredSettingsValidInputRangeTests, testValidInputRangeVehicleTraject value.vehicleMinRadius = valueVehicleMinRadius; ::ad::physics::Duration valueVehicleTrajectoryCalculationStep(0.); value.vehicleTrajectoryCalculationStep = valueVehicleTrajectoryCalculationStep; - uint32_t valueVehicleFrontIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleFrontIntermediateRatioSteps = valueVehicleFrontIntermediateRatioSteps; - uint32_t valueVehicleBackIntermediateRatioSteps{std::numeric_limits::min()}; - value.vehicleBackIntermediateRatioSteps = valueVehicleBackIntermediateRatioSteps; + uint32_t valueVehicleFrontIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleFrontIntermediateYawRateChangeRatioSteps = valueVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueVehicleBackIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleBackIntermediateYawRateChangeRatioSteps = valueVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueVehicleBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleBrakeIntermediateAccelerationSteps = valueVehicleBrakeIntermediateAccelerationSteps; uint32_t valueVehicleContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; value.vehicleContinueForwardIntermediateAccelerationSteps = valueVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps{std::numeric_limits::min()}; + value.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valuePedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianContinueForwardIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianContinueForwardIntermediateAccelerationSteps + = valuePedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valuePedestrianBrakeIntermediateAccelerationSteps{std::numeric_limits::min()}; + value.pedestrianBrakeIntermediateAccelerationSteps = valuePedestrianBrakeIntermediateAccelerationSteps; + uint32_t valuePedestrianFrontIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianFrontIntermediateHeadingChangeRatioSteps = valuePedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valuePedestrianBackIntermediateHeadingChangeRatioSteps{std::numeric_limits::min()}; + value.pedestrianBackIntermediateHeadingChangeRatioSteps = valuePedestrianBackIntermediateHeadingChangeRatioSteps; // override member with data type value above input range maximum ::ad::physics::Duration invalidInitializedMember(1e6 * 1.1); diff --git a/ad_rss/impl/test/generated/ad/rss/world/WorldModelTests.cpp b/ad_rss/impl/test/generated/ad/rss/world/WorldModelTests.cpp index 3c9b46ed12..c836e2e142 100644 --- a/ad_rss/impl/test/generated/ad/rss/world/WorldModelTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/world/WorldModelTests.cpp @@ -84,14 +84,14 @@ class WorldModelTests : public testing::Test ::ad::physics::Duration valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -100,6 +100,33 @@ class WorldModelTests : public testing::Test std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDefaultEgoVehicleRssDynamics.unstructuredSettings = valueDefaultEgoVehicleRssDynamicsUnstructuredSettings; value.defaultEgoVehicleRssDynamics = valueDefaultEgoVehicleRssDynamics; ::ad::rss::world::SceneVector valueScenes; @@ -243,14 +270,14 @@ class WorldModelTests : public testing::Test 0.); valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -260,6 +287,37 @@ class WorldModelTests : public testing::Test std::numeric_limits::min()}; valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings + .vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings + .pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueScenesElementEgoVehicleRssDynamics.unstructuredSettings = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings; valueScenesElement.egoVehicleRssDynamics = valueScenesElementEgoVehicleRssDynamics; @@ -393,14 +451,14 @@ class WorldModelTests : public testing::Test ::ad::physics::Duration valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -409,6 +467,33 @@ class WorldModelTests : public testing::Test std::numeric_limits::min()}; valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t + valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueScenesElementObjectRssDynamics.unstructuredSettings = valueScenesElementObjectRssDynamicsUnstructuredSettings; valueScenesElement.objectRssDynamics = valueScenesElementObjectRssDynamics; ::ad::rss::world::RoadArea valueScenesElementIntersectingRoad; @@ -617,14 +702,14 @@ TEST_F(WorldModelTests, comparisonOperatorDefaultEgoVehicleRssDynamicsDiffers) ::ad::physics::Duration defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(1e6); defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::max()}; defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -633,6 +718,30 @@ TEST_F(WorldModelTests, comparisonOperatorDefaultEgoVehicleRssDynamicsDiffers) std::numeric_limits::max()}; defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + defaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = defaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; defaultEgoVehicleRssDynamics.unstructuredSettings = defaultEgoVehicleRssDynamicsUnstructuredSettings; valueA.defaultEgoVehicleRssDynamics = defaultEgoVehicleRssDynamics; ::ad::rss::world::WorldModel valueB = mValue; @@ -773,14 +882,14 @@ TEST_F(WorldModelTests, comparisonOperatorScenesDiffers) ::ad::physics::Duration scenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(1e6); scenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = scenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t scenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t scenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - scenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = scenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t scenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + scenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = scenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t scenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - scenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = scenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + scenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = scenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t scenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::max()}; scenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -789,6 +898,27 @@ TEST_F(WorldModelTests, comparisonOperatorScenesDiffers) std::numeric_limits::max()}; scenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = scenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + scenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + scenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = scenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t scenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + scenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = scenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t scenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + scenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = scenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t scenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + scenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = scenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t scenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + scenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = scenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; scenesElementEgoVehicleRssDynamics.unstructuredSettings = scenesElementEgoVehicleRssDynamicsUnstructuredSettings; scenesElement.egoVehicleRssDynamics = scenesElementEgoVehicleRssDynamics; ::ad::rss::world::Object scenesElementObject; @@ -906,14 +1036,14 @@ TEST_F(WorldModelTests, comparisonOperatorScenesDiffers) ::ad::physics::Duration scenesElementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(1e6); scenesElementObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = scenesElementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t scenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t scenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - scenesElementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = scenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t scenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + scenesElementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = scenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t scenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::max()}; - scenesElementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = scenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + scenesElementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = scenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t scenesElementObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::max()}; scenesElementObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -922,6 +1052,31 @@ TEST_F(WorldModelTests, comparisonOperatorScenesDiffers) std::numeric_limits::max()}; scenesElementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = scenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t scenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::max()}; + scenesElementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = scenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + scenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + scenesElementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = scenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t scenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + scenesElementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = scenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t scenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::max()}; + scenesElementObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = scenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t scenesElementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + scenesElementObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = scenesElementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t scenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::max()}; + scenesElementObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = scenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; scenesElementObjectRssDynamics.unstructuredSettings = scenesElementObjectRssDynamicsUnstructuredSettings; scenesElement.objectRssDynamics = scenesElementObjectRssDynamics; ::ad::rss::world::RoadArea scenesElementIntersectingRoad; diff --git a/ad_rss/impl/test/generated/ad/rss/world/WorldModelValidInputRangeTests.cpp b/ad_rss/impl/test/generated/ad/rss/world/WorldModelValidInputRangeTests.cpp index c948fd6897..89c87c4c9c 100644 --- a/ad_rss/impl/test/generated/ad/rss/world/WorldModelValidInputRangeTests.cpp +++ b/ad_rss/impl/test/generated/ad/rss/world/WorldModelValidInputRangeTests.cpp @@ -76,14 +76,14 @@ TEST(WorldModelValidInputRangeTests, testValidInputRange) ::ad::physics::Duration valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -92,6 +92,32 @@ TEST(WorldModelValidInputRangeTests, testValidInputRange) std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDefaultEgoVehicleRssDynamics.unstructuredSettings = valueDefaultEgoVehicleRssDynamicsUnstructuredSettings; value.defaultEgoVehicleRssDynamics = valueDefaultEgoVehicleRssDynamics; ::ad::rss::world::SceneVector valueScenes; @@ -234,14 +260,14 @@ TEST(WorldModelValidInputRangeTests, testValidInputRange) 0.); valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -251,6 +277,35 @@ TEST(WorldModelValidInputRangeTests, testValidInputRange) std::numeric_limits::min()}; valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings + .pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueScenesElementEgoVehicleRssDynamics.unstructuredSettings = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings; valueScenesElement.egoVehicleRssDynamics = valueScenesElementEgoVehicleRssDynamics; @@ -383,14 +438,14 @@ TEST(WorldModelValidInputRangeTests, testValidInputRange) ::ad::physics::Duration valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -399,6 +454,33 @@ TEST(WorldModelValidInputRangeTests, testValidInputRange) std::numeric_limits::min()}; valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t + valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueScenesElementObjectRssDynamics.unstructuredSettings = valueScenesElementObjectRssDynamicsUnstructuredSettings; valueScenesElement.objectRssDynamics = valueScenesElementObjectRssDynamics; ::ad::rss::world::RoadArea valueScenesElementIntersectingRoad; @@ -552,14 +634,14 @@ TEST(WorldModelValidInputRangeTests, testValidInputRangeDefaultEgoVehicleRssDyna ::ad::physics::Duration valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -568,6 +650,32 @@ TEST(WorldModelValidInputRangeTests, testValidInputRangeDefaultEgoVehicleRssDyna std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDefaultEgoVehicleRssDynamics.unstructuredSettings = valueDefaultEgoVehicleRssDynamicsUnstructuredSettings; value.defaultEgoVehicleRssDynamics = valueDefaultEgoVehicleRssDynamics; ::ad::rss::world::SceneVector valueScenes; @@ -710,14 +818,14 @@ TEST(WorldModelValidInputRangeTests, testValidInputRangeDefaultEgoVehicleRssDyna 0.); valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -727,6 +835,35 @@ TEST(WorldModelValidInputRangeTests, testValidInputRangeDefaultEgoVehicleRssDyna std::numeric_limits::min()}; valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings + .pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueScenesElementEgoVehicleRssDynamics.unstructuredSettings = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings; valueScenesElement.egoVehicleRssDynamics = valueScenesElementEgoVehicleRssDynamics; @@ -859,14 +996,14 @@ TEST(WorldModelValidInputRangeTests, testValidInputRangeDefaultEgoVehicleRssDyna ::ad::physics::Duration valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -875,6 +1012,33 @@ TEST(WorldModelValidInputRangeTests, testValidInputRangeDefaultEgoVehicleRssDyna std::numeric_limits::min()}; valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t + valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueScenesElementObjectRssDynamics.unstructuredSettings = valueScenesElementObjectRssDynamicsUnstructuredSettings; valueScenesElement.objectRssDynamics = valueScenesElementObjectRssDynamics; ::ad::rss::world::RoadArea valueScenesElementIntersectingRoad; @@ -1036,14 +1200,14 @@ TEST(WorldModelValidInputRangeTests, testValidInputRangeDefaultEgoVehicleRssDyna ::ad::physics::Duration valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1052,6 +1216,32 @@ TEST(WorldModelValidInputRangeTests, testValidInputRangeDefaultEgoVehicleRssDyna std::numeric_limits::min()}; valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueDefaultEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueDefaultEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueDefaultEgoVehicleRssDynamics.unstructuredSettings = valueDefaultEgoVehicleRssDynamicsUnstructuredSettings; value.defaultEgoVehicleRssDynamics = valueDefaultEgoVehicleRssDynamics; ::ad::rss::world::SceneVector valueScenes; @@ -1194,14 +1384,14 @@ TEST(WorldModelValidInputRangeTests, testValidInputRangeDefaultEgoVehicleRssDyna 0.); valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1211,6 +1401,35 @@ TEST(WorldModelValidInputRangeTests, testValidInputRangeDefaultEgoVehicleRssDyna std::numeric_limits::min()}; valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings + .pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueScenesElementEgoVehicleRssDynamics.unstructuredSettings = valueScenesElementEgoVehicleRssDynamicsUnstructuredSettings; valueScenesElement.egoVehicleRssDynamics = valueScenesElementEgoVehicleRssDynamics; @@ -1343,14 +1562,14 @@ TEST(WorldModelValidInputRangeTests, testValidInputRangeDefaultEgoVehicleRssDyna ::ad::physics::Duration valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep(0.); valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleTrajectoryCalculationStep = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleTrajectoryCalculationStep; - uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps{ + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateRatioSteps - = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateRatioSteps; - uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps{ + valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleFrontIntermediateYawRateChangeRatioSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps{ std::numeric_limits::min()}; - valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateRatioSteps - = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateRatioSteps; + valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBackIntermediateYawRateChangeRatioSteps; uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleBrakeIntermediateAccelerationSteps{ std::numeric_limits::min()}; valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleBrakeIntermediateAccelerationSteps @@ -1359,6 +1578,33 @@ TEST(WorldModelValidInputRangeTests, testValidInputRangeDefaultEgoVehicleRssDyna std::numeric_limits::min()}; valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateAccelerationSteps; + uint32_t + valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsVehicleContinueForwardIntermediateYawRateChangeRatioSteps; + uint32_t + valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateHeadingChangeRatioSteps; + uint32_t + valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianContinueForwardIntermediateAccelerationSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBrakeIntermediateAccelerationSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianFrontIntermediateHeadingChangeRatioSteps; + uint32_t valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps{ + std::numeric_limits::min()}; + valueScenesElementObjectRssDynamicsUnstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps + = valueScenesElementObjectRssDynamicsUnstructuredSettingsPedestrianBackIntermediateHeadingChangeRatioSteps; valueScenesElementObjectRssDynamics.unstructuredSettings = valueScenesElementObjectRssDynamicsUnstructuredSettings; valueScenesElement.objectRssDynamics = valueScenesElementObjectRssDynamics; ::ad::rss::world::RoadArea valueScenesElementIntersectingRoad; diff --git a/ad_rss/impl/test/test_support/TestSupport.cpp b/ad_rss/impl/test/test_support/TestSupport.cpp index b10ea4d598..cb6f90787f 100644 --- a/ad_rss/impl/test/test_support/TestSupport.cpp +++ b/ad_rss/impl/test/test_support/TestSupport.cpp @@ -92,6 +92,17 @@ world::RssDynamics getObjectRssDynamics() rssDynamics.unstructuredSettings.vehicleMinRadius = ad::physics::Distance(3.5); rssDynamics.unstructuredSettings.vehicleTrajectoryCalculationStep = ad::physics::Duration(0.2); + rssDynamics.unstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps = 3; + rssDynamics.unstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps = 0; + rssDynamics.unstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = 1; + rssDynamics.unstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = 0; + rssDynamics.unstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps = 3; + rssDynamics.unstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps = 3; + rssDynamics.unstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps = 0; + rssDynamics.unstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps = 3; + rssDynamics.unstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps = 4; + rssDynamics.unstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps = 0; + return rssDynamics; } @@ -115,6 +126,16 @@ world::RssDynamics getEgoRssDynamics() rssDynamics.unstructuredSettings.vehicleMinRadius = ad::physics::Distance(3.5); rssDynamics.unstructuredSettings.vehicleTrajectoryCalculationStep = ad::physics::Duration(0.2); + rssDynamics.unstructuredSettings.vehicleFrontIntermediateYawRateChangeRatioSteps = 3; + rssDynamics.unstructuredSettings.vehicleBackIntermediateYawRateChangeRatioSteps = 0; + rssDynamics.unstructuredSettings.vehicleBrakeIntermediateAccelerationSteps = 1; + rssDynamics.unstructuredSettings.vehicleContinueForwardIntermediateAccelerationSteps = 0; + rssDynamics.unstructuredSettings.vehicleContinueForwardIntermediateYawRateChangeRatioSteps = 3; + rssDynamics.unstructuredSettings.pedestrianContinueForwardIntermediateHeadingChangeRatioSteps = 3; + rssDynamics.unstructuredSettings.pedestrianContinueForwardIntermediateAccelerationSteps = 0; + rssDynamics.unstructuredSettings.pedestrianBrakeIntermediateAccelerationSteps = 3; + rssDynamics.unstructuredSettings.pedestrianFrontIntermediateHeadingChangeRatioSteps = 4; + rssDynamics.unstructuredSettings.pedestrianBackIntermediateHeadingChangeRatioSteps = 0; return rssDynamics; } diff --git a/doc/CHANGELOG.md b/doc/CHANGELOG.md index d31ff9e10a..8724d55bc6 100644 --- a/doc/CHANGELOG.md +++ b/doc/CHANGELOG.md @@ -1,12 +1,16 @@ ## Latest changes +## Release 4.4.0 + +#### :ghost: Maintenance +* Unstructured constellation polygon creation: Add several parameters to adjust polygon calculation. Fix issues, refactor code. + ## Release 4.3.0 #### :ghost: Maintenance * Unstructured constellation polygon creation: Fix vehicle curvature calculation after response time, make DebugDrawing accessible from python - ## Release 4.2.0 #### :ghost: Maintenance diff --git a/doc/ad_rss/UnstructuredConstellations.md b/doc/ad_rss/UnstructuredConstellations.md index 02af6e04c8..839b4f9378 100644 --- a/doc/ad_rss/UnstructuredConstellations.md +++ b/doc/ad_rss/UnstructuredConstellations.md @@ -60,13 +60,14 @@ The calculation is done in three steps. In the first step, the vehicle state at response time is calculated by using time increments, specified by `UnstructuredSettings::vehicleTrajectoryCalculationStep`. (This might lead to an increasing error the farer the point is). The amount of states can be customized by several parameters: -- `UnstructuredSettings::vehicleBackIntermediateRatioSteps` specifies how many steps beside maximum yaw rate change to the left/right and no change at all should be calculated. The value is specifying the steps on one side, therefore the resulting intermediate steps are twice this value. This value is used for the back of the trajectory set. -- `UnstructuredSettings::vehicleFrontIntermediateRatioSteps` similar to above, but for the front of the trajectory set. +- `UnstructuredSettings::vehicleBackIntermediateYawRateChangeRatioSteps` specifies how many steps beside maximum yaw rate change to the left/right and no change at all should be calculated. The value is specifying the steps on one side, therefore the resulting intermediate steps are twice this value. This value is used for the back of the trajectory set. +- `UnstructuredSettings::vehicleFrontIntermediateYawRateChangeRatioSteps` similar to above, but for the front of the trajectory set. In the second step, the final vehicle state is calculated for each of the response-time vehicle states by using the corresponding acceleration driven on a circle. The following parameters can be specified: - `UnstructuredSettings::vehicleContinueForwardIntermediateAccelerationSteps` specifies the intermediate acceleration steps (between brakeMin and accelMax) used while calculating the continue forward trajectory set. - `UnstructuredSettings::vehicleBrakeIntermediateAccelerationSteps` specifies the intermediate acceleration steps (between brakeMax and brakeMin) used while calculating the brake trajectory set. +- `UnstructuredSettings::vehicleContinueForwardIntermediateYawRateChangeRatioSteps` specifies the intermediate yaw rate change ratio steps used while calculating the continue forward trajectory set. In the third step the final trajectory sets are calculated. To reach an acceptable calculation time some simplification are applied. Keep in mind, that this might cause invalid responses! For each value of acceleration a final state is calculated. This contains of at least three vehicles states: two with maximum yaw rate change to left and right and one with no yaw rate change. For the back and front of the trajectory set there might also be intermediate values for the yaw rate change. For the front a convex hull of all states (including vehicle dimensions) is calculated. For the ones defining the sides of the trajectory set (where only max left/right and center vehicle state are available) a polygon is calculated by merging the convex hull of left+center and right+center. To create the trajectory set all polygons are merged together, including polygons for the linear estimation between the steps. @@ -76,6 +77,14 @@ In the third step the final trajectory sets are calculated. To reach an acceptab * At emergency, after the response time, the pedestrian will continue at a straight line * If the pedestrian is standing, we assign it to all possible lines originating from his current position. +Similar to the vehicle calculations the following settings can be used to improve the precision of the polygons: + +* `UnstructuredSettings::pedestrianContinueForwardIntermediateHeadingChangeRatioSteps` specifies the intermediate heading change ratio steps used while calculating the continue forward trajectory set. +* `UnstructuredSettings::pedestrianContinueForwardIntermediateAccelerationSteps` specifies the intermediate steps used while calculating the continue forward trajectory set. (As the pedestrian at max moves on a circle, this value specifies how many points on the circle arc are used) +* `UnstructuredSettings::pedestrianBrakeIntermediateAccelerationSteps` specifies the intermediate steps used while calculating the brake trajectory set. +* `UnstructuredSettings::pedestrianFrontIntermediateHeadingChangeRatioSteps` specifies the intermediate steps that are used. The value is specifying the steps on one side, therefore the resulting intermediate steps are twice this value. This value is used for the front of the trajectory set. +* `UnstructuredSettings::pedestrianBackIntermediateHeadingChangeRatioSteps` specifies the intermediate steps that are used. The value is specifying the steps on one side, therefore the resulting intermediate steps are twice this value. This value is used for the front of the trajectory set. + ### Decision making The [RSS paper](https://arxiv.org/abs/1708.06374) definition 22 states conditions, that are relevant to calculate if a constellation is dangerous and how to behave then.