new gpr

data_acq_and_processing/common_cpp/config/include/run_config.hpp

@@ -129,7 +129,6 @@ struct GprRxGeometry {
 
 struct GprConfig {
     // Stable collection-level GPR processing settings.
-    std::string mode = "point";
     float relative_permittivity = 1.0F;
     std::vector<GprTxGeometry> tx_geometry{};
     std::vector<GprRxGeometry> rx_geometry{};

data_acq_and_processing/common_cpp/config/src/run_config.cpp

@@ -271,9 +271,6 @@ void validate_combo_key(const ipc::ComboKey& key, const RunConfig& config) {
 }
 
 void validate_gpr_config(const GprConfig& config, const RunConfig& run_config) {
-    if (config.mode != "point" && config.mode != "extended") {
-        throw std::runtime_error("gpr.mode must be either 'point' or 'extended'");
-    }
     if (!(config.relative_permittivity > 0.0F)) {
         throw std::runtime_error("gpr.relative_permittivity must be > 0");
     }
@@ -302,7 +299,6 @@ void validate_gpr_config(const GprConfig& config, const RunConfig& run_config) {
 [[nodiscard]] auto parse_gpr_config(const Json& object, const RunConfig& run_config) -> GprConfig {
     const auto* gpr_obj = as_object(object, "gpr");
     GprConfig config{};
-    config.mode = optional_string(*gpr_obj, "mode", "point");
     config.relative_permittivity = optional_f32(*gpr_obj, "relative_permittivity", 1.0F);
 
     if (const auto* tx_value = optional_field(*gpr_obj, "tx_geometry"); tx_value != nullptr) {

data_acq_and_processing/processing/data_processor/include/processing_live_config.hpp

@@ -2,7 +2,6 @@
 
 #include <chrono>
 #include <cstdint>
-#include <filesystem>
 #include <string>
 #include <vector>
 
@@ -31,15 +30,13 @@ struct ProcessingLiveConfig {
     std::vector<std::uint32_t> gpr_output_positions{};
     float gpr_min_depth_m = 2.0F;
     float gpr_max_depth_m = 14.0F;
-    float gpr_comp_power = 0.2F;
+    float gpr_range_comp_power = 0.28F;
+    float gpr_angle_comp_power = 0.10F;
     float gpr_start_freq_mhz = 3000.0F;
     float gpr_stop_freq_mhz = 6000.0F;
-    float gpr_speed_m_s = 0.0F;
-    float gpr_look_angle_deg = 0.0F;
-    float gpr_snr_thresh = 4.5F;
-    float gpr_snr_comp_max = 25.0F;
     bool gpr_background_subtract_enabled = true;
     std::uint32_t gpr_background_mean_count = 10U;
+    bool gpr_remove_sidelobe_objects_enabled = true;
     std::uint64_t history_command_seq = 0;
     HistoryCommand history_command = HistoryCommand::None;
 };
@@ -53,12 +50,12 @@ class ProcessingLiveConfigLoader {
     [[nodiscard]] auto revision() const -> std::uint64_t;
 
   private:
-    [[nodiscard]] auto read_from_file() const -> ProcessingLiveConfig;
+    [[nodiscard]] auto read_file_text() const -> std::string;
 
     std::string path_{};
     ProcessingLiveConfig current_{};
-    std::filesystem::file_time_type last_write_time_{};
-    bool has_last_write_time_ = false;
+    std::string last_json_text_{};
+    bool has_last_json_text_ = false;
     std::uint64_t revision_ = 0;
     std::chrono::steady_clock::time_point next_check_at_{};
 };

data_acq_and_processing/processing/data_processor/src/processing_live_config.cpp

@@ -2,6 +2,7 @@
 
 #include <chrono>
 #include <cmath>
+#include <filesystem>
 #include <fstream>
 #include <iostream>
 #include <limits>
@@ -181,11 +182,17 @@ using Json = nlohmann::json;
         }
         config.gpr_max_depth_m = static_cast<float>(found->get<double>());
     }
-    if (const auto found = root.find("gpr_comp_power"); found != root.end()) {
+    if (const auto found = root.find("gpr_range_comp_power"); found != root.end()) {
         if (!found->is_number()) {
-            throw std::runtime_error("processing.gpr_comp_power must be number");
+            throw std::runtime_error("processing.gpr_range_comp_power must be number");
         }
-        config.gpr_comp_power = static_cast<float>(found->get<double>());
+        config.gpr_range_comp_power = static_cast<float>(found->get<double>());
+    }
+    if (const auto found = root.find("gpr_angle_comp_power"); found != root.end()) {
+        if (!found->is_number()) {
+            throw std::runtime_error("processing.gpr_angle_comp_power must be number");
+        }
+        config.gpr_angle_comp_power = static_cast<float>(found->get<double>());
     }
     if (const auto found = root.find("gpr_start_freq_mhz"); found != root.end()) {
         if (!found->is_number()) {
@@ -199,30 +206,6 @@ using Json = nlohmann::json;
         }
         config.gpr_stop_freq_mhz = static_cast<float>(found->get<double>());
     }
-    if (const auto found = root.find("gpr_speed_m_s"); found != root.end()) {
-        if (!found->is_number()) {
-            throw std::runtime_error("processing.gpr_speed_m_s must be number");
-        }
-        config.gpr_speed_m_s = static_cast<float>(found->get<double>());
-    }
-    if (const auto found = root.find("gpr_look_angle_deg"); found != root.end()) {
-        if (!found->is_number()) {
-            throw std::runtime_error("processing.gpr_look_angle_deg must be number");
-        }
-        config.gpr_look_angle_deg = static_cast<float>(found->get<double>());
-    }
-    if (const auto found = root.find("gpr_snr_thresh"); found != root.end()) {
-        if (!found->is_number()) {
-            throw std::runtime_error("processing.gpr_snr_thresh must be number");
-        }
-        config.gpr_snr_thresh = static_cast<float>(found->get<double>());
-    }
-    if (const auto found = root.find("gpr_snr_comp_max"); found != root.end()) {
-        if (!found->is_number()) {
-            throw std::runtime_error("processing.gpr_snr_comp_max must be number");
-        }
-        config.gpr_snr_comp_max = static_cast<float>(found->get<double>());
-    }
     if (const auto found = root.find("gpr_background_subtract_enabled"); found != root.end()) {
         if (!found->is_boolean()) {
             throw std::runtime_error("processing.gpr_background_subtract_enabled must be bool");
@@ -232,6 +215,12 @@ using Json = nlohmann::json;
     if (const auto found = root.find("gpr_background_mean_count"); found != root.end()) {
         config.gpr_background_mean_count = parse_u32_number(*found, "processing.gpr_background_mean_count");
     }
+    if (const auto found = root.find("gpr_remove_sidelobe_objects_enabled"); found != root.end()) {
+        if (!found->is_boolean()) {
+            throw std::runtime_error("processing.gpr_remove_sidelobe_objects_enabled must be bool");
+        }
+        config.gpr_remove_sidelobe_objects_enabled = found->get<bool>();
+    }
     if (const auto found = root.find("history_command_seq"); found != root.end()) {
         config.history_command_seq = parse_u64_number(*found, "processing.history_command_seq");
     }
@@ -269,20 +258,20 @@ auto ProcessingLiveConfigLoader::refresh_if_needed() -> ProcessingLiveConfig {
     }
     next_check_at_ = now + std::chrono::milliseconds(100);
 
-    std::error_code time_error{};
-    const auto file_time = std::filesystem::last_write_time(path_, time_error);
-    if (time_error) {
-        return current_;
-    }
-
-    if (has_last_write_time_ && file_time == last_write_time_) {
+    std::error_code file_error{};
+    if (!std::filesystem::exists(path_, file_error) || file_error) {
         return current_;
     }
 
     try {
-        current_ = read_from_file();
-        last_write_time_ = file_time;
-        has_last_write_time_ = true;
+        const auto json_text = read_file_text();
+        if (has_last_json_text_ && json_text == last_json_text_) {
+            return current_;
+        }
+
+        current_ = parse_live_config(json_text, path_);
+        last_json_text_ = json_text;
+        has_last_json_text_ = true;
         ++revision_;
     } catch (const std::exception& error) {
         std::cerr << "data_processor warning: failed to refresh live processing config: " << error.what() << '\n';
@@ -291,7 +280,7 @@ auto ProcessingLiveConfigLoader::refresh_if_needed() -> ProcessingLiveConfig {
     return current_;
 }
 
-auto ProcessingLiveConfigLoader::read_from_file() const -> ProcessingLiveConfig {
+auto ProcessingLiveConfigLoader::read_file_text() const -> std::string {
     std::ifstream stream(path_);
     if (!stream.is_open()) {
         throw std::runtime_error("Failed to open live processing config: " + path_);
@@ -299,7 +288,7 @@ auto ProcessingLiveConfigLoader::read_from_file() const -> ProcessingLiveConfig
 
     std::stringstream buffer{};
     buffer << stream.rdbuf();
-    return parse_live_config(buffer.str(), path_);
+    return buffer.str();
 }
 
 }  // namespace radar::processing