fixed UI

data_acq_and_processing/processing/data_processor/include/processing_live_config.hpp

@@ -13,10 +13,9 @@ enum class HistoryCommand {
     ClearAll,
 };
 
-enum class GprAlgorithm {
-    Backprojection,
-    LegacyPoint,
-    LegacyExtended,
+enum class LegacyGprMode {
+    Point,
+    Extended,
 };
 
 struct ProcessingLiveConfig {
@@ -32,7 +31,7 @@ struct ProcessingLiveConfig {
     float bscan_gain = 1.0F;
     float bscan_start_freq_mhz = 100.0F;
     float bscan_stop_freq_mhz = 8800.0F;
-    GprAlgorithm gpr_algorithm = GprAlgorithm::Backprojection;
+    LegacyGprMode legacy_gpr_mode = LegacyGprMode::Point;
     std::vector<std::uint32_t> gpr_input_positions{};
     std::vector<std::uint32_t> gpr_output_positions{};
     float gpr_min_depth_m = 2.0F;

data_acq_and_processing/processing/data_processor/src/data_processor.cpp

@@ -162,6 +162,10 @@ auto create_default_processors() -> ProcessorRegistry {
         auto processor = std::make_unique<GprProcessor>();
         processors.emplace(processor->name(), std::move(processor));
     }
+    {
+        auto processor = std::make_unique<LegacyGprProcessor>();
+        processors.emplace(processor->name(), std::move(processor));
+    }
     return processors;
 }
 

data_acq_and_processing/processing/data_processor/src/processing_live_config.cpp

@@ -31,19 +31,32 @@ using Json = nlohmann::json;
     throw std::runtime_error("processing.history_command must be one of: none, remove_last, clear_all");
 }
 
-[[nodiscard]] auto parse_gpr_algorithm(const std::string& value) -> GprAlgorithm {
+[[nodiscard]] auto parse_legacy_gpr_mode(const std::string& value, const std::string& field_name) -> LegacyGprMode {
+    if (value == "point") {
+        return LegacyGprMode::Point;
+    }
+    if (value == "extended") {
+        return LegacyGprMode::Extended;
+    }
+    throw std::runtime_error(field_name + " must be one of: point, extended");
+}
+
+void apply_legacy_gpr_algorithm_alias(ProcessingLiveConfig& config, const std::string& value) {
     if (value == "backprojection") {
-        return GprAlgorithm::Backprojection;
+        return;
     }
     if (value == "legacy_point") {
-        return GprAlgorithm::LegacyPoint;
+        config.legacy_gpr_mode = LegacyGprMode::Point;
+    } else if (value == "legacy_extended") {
+        config.legacy_gpr_mode = LegacyGprMode::Extended;
+    } else {
+        throw std::runtime_error(
+            "processing.gpr_algorithm must be one of: backprojection, legacy_point, legacy_extended"
+        );
     }
-    if (value == "legacy_extended") {
-        return GprAlgorithm::LegacyExtended;
+    if (config.processor_mode.empty() || config.processor_mode == "gpr") {
+        config.processor_mode = "legacy_gpr";
     }
-    throw std::runtime_error(
-        "processing.gpr_algorithm must be one of: backprojection, legacy_point, legacy_extended"
-    );
 }
 
 [[nodiscard]] auto parse_s_parameter_channel(const std::string& value, const std::string& field_name) -> std::string {
@@ -179,11 +192,18 @@ using Json = nlohmann::json;
         }
         config.bscan_stop_freq_mhz = static_cast<float>(found->get<double>());
     }
+    if (const auto found = root.find("legacy_gpr_mode"); found != root.end()) {
+        if (!found->is_string()) {
+            throw std::runtime_error("processing.legacy_gpr_mode must be string");
+        }
+        config.legacy_gpr_mode =
+            parse_legacy_gpr_mode(found->get<std::string>(), "processing.legacy_gpr_mode");
+    }
     if (const auto found = root.find("gpr_algorithm"); found != root.end()) {
         if (!found->is_string()) {
             throw std::runtime_error("processing.gpr_algorithm must be string");
         }
-        config.gpr_algorithm = parse_gpr_algorithm(found->get<std::string>());
+        apply_legacy_gpr_algorithm_alias(config, found->get<std::string>());
     }
     if (const auto found = root.find("gpr_input_positions"); found != root.end()) {
         config.gpr_input_positions = parse_u32_array(*found, "processing.gpr_input_positions");