refactor: nest epdms aggregation structs

Author: beomseok-kimm

planning/autoware_planning_data_analyzer/src/metrics/epdms_aggregation.cpp

@@ -39,74 +39,76 @@ HumanFilterMetrics calculate_human_filter_metrics(
 {
   HumanFilterMetrics result;
 
-  result.human_history_comfort = human_metrics.history_comfort;
-  result.human_history_comfort_available = human_metrics.history_comfort_available;
-  result.filtered_history_comfort = apply_human_filter(
+  result.history_comfort.human_reference = human_metrics.history_comfort;
+  result.history_comfort.human_reference_available = human_metrics.history_comfort_available;
+  result.history_comfort.filtered = apply_human_filter(
     agent_metrics.history_comfort, agent_metrics.history_comfort_available,
     human_metrics.history_comfort, human_metrics.history_comfort_available,
-    result.history_comfort_filter_applied);
+    result.history_comfort.filter_applied);
 
-  result.human_extended_comfort = human_metrics.extended_comfort;
-  result.human_extended_comfort_available = human_metrics.extended_comfort_available;
-  result.filtered_extended_comfort = apply_human_filter(
+  result.extended_comfort.human_reference = human_metrics.extended_comfort;
+  result.extended_comfort.human_reference_available = human_metrics.extended_comfort_available;
+  result.extended_comfort.filtered = apply_human_filter(
     agent_metrics.extended_comfort, agent_metrics.extended_comfort_available,
     human_metrics.extended_comfort, human_metrics.extended_comfort_available,
-    result.extended_comfort_filter_applied);
+    result.extended_comfort.filter_applied);
 
-  result.human_ego_progress = human_metrics.ego_progress;
-  result.human_ego_progress_available = human_metrics.ego_progress_available;
-  result.filtered_ego_progress = apply_human_filter(
+  result.ego_progress.human_reference = human_metrics.ego_progress;
+  result.ego_progress.human_reference_available = human_metrics.ego_progress_available;
+  result.ego_progress.filtered = apply_human_filter(
     agent_metrics.ego_progress, agent_metrics.ego_progress_available, human_metrics.ego_progress,
-    human_metrics.ego_progress_available, result.ego_progress_filter_applied);
+    human_metrics.ego_progress_available, result.ego_progress.filter_applied);
 
-  result.human_time_to_collision_within_bound = human_metrics.time_to_collision_within_bound;
-  result.human_time_to_collision_within_bound_available =
+  result.time_to_collision_within_bound.human_reference =
+    human_metrics.time_to_collision_within_bound;
+  result.time_to_collision_within_bound.human_reference_available =
     human_metrics.time_to_collision_within_bound_available;
-  result.filtered_time_to_collision_within_bound = apply_human_filter(
+  result.time_to_collision_within_bound.filtered = apply_human_filter(
     agent_metrics.time_to_collision_within_bound,
     agent_metrics.time_to_collision_within_bound_available,
     human_metrics.time_to_collision_within_bound,
     human_metrics.time_to_collision_within_bound_available,
-    result.time_to_collision_within_bound_filter_applied);
+    result.time_to_collision_within_bound.filter_applied);
 
-  result.human_lane_keeping = human_metrics.lane_keeping;
-  result.human_lane_keeping_available = human_metrics.lane_keeping_available;
-  result.filtered_lane_keeping = apply_human_filter(
+  result.lane_keeping.human_reference = human_metrics.lane_keeping;
+  result.lane_keeping.human_reference_available = human_metrics.lane_keeping_available;
+  result.lane_keeping.filtered = apply_human_filter(
     agent_metrics.lane_keeping, agent_metrics.lane_keeping_available, human_metrics.lane_keeping,
-    human_metrics.lane_keeping_available, result.lane_keeping_filter_applied);
+    human_metrics.lane_keeping_available, result.lane_keeping.filter_applied);
 
-  result.human_drivable_area_compliance = human_metrics.drivable_area_compliance;
-  result.human_drivable_area_compliance_available =
+  result.drivable_area_compliance.human_reference = human_metrics.drivable_area_compliance;
+  result.drivable_area_compliance.human_reference_available =
     human_metrics.drivable_area_compliance_available;
-  result.filtered_drivable_area_compliance = apply_human_filter(
+  result.drivable_area_compliance.filtered = apply_human_filter(
     agent_metrics.drivable_area_compliance, agent_metrics.drivable_area_compliance_available,
     human_metrics.drivable_area_compliance, human_metrics.drivable_area_compliance_available,
-    result.drivable_area_compliance_filter_applied);
+    result.drivable_area_compliance.filter_applied);
 
-  result.human_no_at_fault_collision = human_metrics.no_at_fault_collision;
-  result.human_no_at_fault_collision_available = human_metrics.no_at_fault_collision_available;
-  result.filtered_no_at_fault_collision = apply_human_filter(
+  result.no_at_fault_collision.human_reference = human_metrics.no_at_fault_collision;
+  result.no_at_fault_collision.human_reference_available =
+    human_metrics.no_at_fault_collision_available;
+  result.no_at_fault_collision.filtered = apply_human_filter(
     agent_metrics.no_at_fault_collision, agent_metrics.no_at_fault_collision_available,
     human_metrics.no_at_fault_collision, human_metrics.no_at_fault_collision_available,
-    result.no_at_fault_collision_filter_applied);
+    result.no_at_fault_collision.filter_applied);
 
-  result.human_driving_direction_compliance = human_metrics.driving_direction_compliance;
-  result.human_driving_direction_compliance_available =
+  result.driving_direction_compliance.human_reference = human_metrics.driving_direction_compliance;
+  result.driving_direction_compliance.human_reference_available =
     human_metrics.driving_direction_compliance_available;
-  result.filtered_driving_direction_compliance = apply_human_filter(
+  result.driving_direction_compliance.filtered = apply_human_filter(
     agent_metrics.driving_direction_compliance,
     agent_metrics.driving_direction_compliance_available,
     human_metrics.driving_direction_compliance,
     human_metrics.driving_direction_compliance_available,
-    result.driving_direction_compliance_filter_applied);
+    result.driving_direction_compliance.filter_applied);
 
-  result.human_traffic_light_compliance = human_metrics.traffic_light_compliance;
-  result.human_traffic_light_compliance_available =
+  result.traffic_light_compliance.human_reference = human_metrics.traffic_light_compliance;
+  result.traffic_light_compliance.human_reference_available =
     human_metrics.traffic_light_compliance_available;
-  result.filtered_traffic_light_compliance = apply_human_filter(
+  result.traffic_light_compliance.filtered = apply_human_filter(
     agent_metrics.traffic_light_compliance, agent_metrics.traffic_light_compliance_available,
     human_metrics.traffic_light_compliance, human_metrics.traffic_light_compliance_available,
-    result.traffic_light_compliance_filter_applied);
+    result.traffic_light_compliance.filter_applied);
 
   return result;
 }
@@ -126,17 +128,17 @@ SyntheticEpdmsMetrics calculate_synthetic_epdms(
                                       agent_metrics.lane_keeping_available &&
                                       agent_metrics.history_comfort_available &&
                                       agent_metrics.extended_comfort_available;
-  result.raw_available = raw_multiplicative_available && raw_weighted_available;
-  if (result.raw_available) {
-    result.raw_multiplicative_metrics_prod =
+  result.raw.available = raw_multiplicative_available && raw_weighted_available;
+  if (result.raw.available) {
+    result.raw.multiplicative_metrics_prod =
       agent_metrics.no_at_fault_collision * agent_metrics.drivable_area_compliance *
       agent_metrics.driving_direction_compliance * agent_metrics.traffic_light_compliance;
-    result.raw_weighted_metrics =
+    result.raw.weighted_metrics =
       (5.0 * agent_metrics.ego_progress + 5.0 * agent_metrics.time_to_collision_within_bound +
        2.0 * agent_metrics.lane_keeping + 2.0 * agent_metrics.history_comfort +
        2.0 * agent_metrics.extended_comfort) /
       kSyntheticWeightedDenominator;
-    result.raw_epdms = result.raw_multiplicative_metrics_prod * result.raw_weighted_metrics;
+    result.raw.epdms = result.raw.multiplicative_metrics_prod * result.raw.weighted_metrics;
   }
 
   const bool human_filtered_multiplicative_available =
@@ -149,25 +151,25 @@ SyntheticEpdmsMetrics calculate_synthetic_epdms(
     agent_metrics.time_to_collision_within_bound_available &&
     agent_metrics.lane_keeping_available && agent_metrics.history_comfort_available &&
     agent_metrics.extended_comfort_available;
-  result.human_filtered_available =
+  result.human_filtered.available =
     human_filtered_multiplicative_available && human_filtered_weighted_available;
-  if (result.human_filtered_available) {
-    result.human_filtered_multiplicative_metrics_prod =
-      human_filter_metrics.filtered_no_at_fault_collision *
-      human_filter_metrics.filtered_drivable_area_compliance *
-      human_filter_metrics.filtered_driving_direction_compliance *
-      human_filter_metrics.filtered_traffic_light_compliance;
+  if (result.human_filtered.available) {
+    result.human_filtered.multiplicative_metrics_prod =
+      human_filter_metrics.no_at_fault_collision.filtered *
+      human_filter_metrics.drivable_area_compliance.filtered *
+      human_filter_metrics.driving_direction_compliance.filtered *
+      human_filter_metrics.traffic_light_compliance.filtered;
     const double filtered_ego_progress =
-      human_filter_metrics.ego_progress_filter_applied ? 1.0 : agent_metrics.ego_progress;
-    result.human_filtered_weighted_metrics =
+      human_filter_metrics.ego_progress.filter_applied ? 1.0 : agent_metrics.ego_progress;
+    result.human_filtered.weighted_metrics =
       (5.0 * filtered_ego_progress +
-       5.0 * human_filter_metrics.filtered_time_to_collision_within_bound +
-       2.0 * human_filter_metrics.filtered_lane_keeping +
-       2.0 * human_filter_metrics.filtered_history_comfort +
-       2.0 * human_filter_metrics.filtered_extended_comfort) /
+       5.0 * human_filter_metrics.time_to_collision_within_bound.filtered +
+       2.0 * human_filter_metrics.lane_keeping.filtered +
+       2.0 * human_filter_metrics.history_comfort.filtered +
+       2.0 * human_filter_metrics.extended_comfort.filtered) /
       kSyntheticWeightedDenominator;
-    result.human_filtered_epdms =
-      result.human_filtered_multiplicative_metrics_prod * result.human_filtered_weighted_metrics;
+    result.human_filtered.epdms =
+      result.human_filtered.multiplicative_metrics_prod * result.human_filtered.weighted_metrics;
   }
 
   return result;

planning/autoware_planning_data_analyzer/src/metrics/epdms_aggregation.hpp

@@ -52,63 +52,37 @@ struct EpdmsMetricSnapshot
 
 struct HumanFilterMetrics
 {
-  double human_history_comfort{0.0};
-  bool human_history_comfort_available{false};
-  double filtered_history_comfort{0.0};
-  bool history_comfort_filter_applied{false};
-
-  double human_extended_comfort{0.0};
-  bool human_extended_comfort_available{false};
-  double filtered_extended_comfort{0.0};
-  bool extended_comfort_filter_applied{false};
-
-  double human_ego_progress{0.0};
-  bool human_ego_progress_available{false};
-  double filtered_ego_progress{0.0};
-  bool ego_progress_filter_applied{false};
-
-  double human_time_to_collision_within_bound{0.0};
-  bool human_time_to_collision_within_bound_available{false};
-  double filtered_time_to_collision_within_bound{0.0};
-  bool time_to_collision_within_bound_filter_applied{false};
-
-  double human_lane_keeping{0.0};
-  bool human_lane_keeping_available{false};
-  double filtered_lane_keeping{0.0};
-  bool lane_keeping_filter_applied{false};
-
-  double human_drivable_area_compliance{0.0};
-  bool human_drivable_area_compliance_available{false};
-  double filtered_drivable_area_compliance{0.0};
-  bool drivable_area_compliance_filter_applied{false};
-
-  double human_no_at_fault_collision{0.0};
-  bool human_no_at_fault_collision_available{false};
-  double filtered_no_at_fault_collision{0.0};
-  bool no_at_fault_collision_filter_applied{false};
-
-  double human_driving_direction_compliance{0.0};
-  bool human_driving_direction_compliance_available{false};
-  double filtered_driving_direction_compliance{0.0};
-  bool driving_direction_compliance_filter_applied{false};
-
-  double human_traffic_light_compliance{0.0};
-  bool human_traffic_light_compliance_available{false};
-  double filtered_traffic_light_compliance{0.0};
-  bool traffic_light_compliance_filter_applied{false};
+  struct Metric
+  {
+    double human_reference{0.0};
+    bool human_reference_available{false};
+    double filtered{0.0};
+    bool filter_applied{false};
+  };
+
+  Metric history_comfort;
+  Metric extended_comfort;
+  Metric ego_progress;
+  Metric time_to_collision_within_bound;
+  Metric lane_keeping;
+  Metric drivable_area_compliance;
+  Metric no_at_fault_collision;
+  Metric driving_direction_compliance;
+  Metric traffic_light_compliance;
 };
 
 struct SyntheticEpdmsMetrics
 {
-  bool raw_available{false};
-  double raw_multiplicative_metrics_prod{0.0};
-  double raw_weighted_metrics{0.0};
-  double raw_epdms{0.0};
-
-  bool human_filtered_available{false};
-  double human_filtered_multiplicative_metrics_prod{0.0};
-  double human_filtered_weighted_metrics{0.0};
-  double human_filtered_epdms{0.0};
+  struct Stage
+  {
+    bool available{false};
+    double multiplicative_metrics_prod{0.0};
+    double weighted_metrics{0.0};
+    double epdms{0.0};
+  };
+
+  Stage raw;
+  Stage human_filtered;
 };
 
 HumanFilterMetrics calculate_human_filter_metrics(