Update GPR and SAR3D processing

2026-10-08 16:24:01 +03:00
parent 390015ec39
commit 3575ca68f5
67 changed files with 1187 additions and 2581 deletions
@@ -0,0 +1,113 @@
+#include "sar3d_processor.hpp"
+#include "gpr_processor.hpp"
+
+#include <algorithm>
+#include <complex>
+#include <iostream>
+#include <vector>
+#include <nlohmann/json.hpp>
+
+using Json = nlohmann::json;
+using namespace radar;
+
+namespace {
+auto complex_samples(const Json& samples) -> std::vector<std::complex<float>> {
+    std::vector<std::complex<float>> values;
+    for (const auto& sample : samples) {
+        values.emplace_back(sample.at(0).get<float>(), sample.at(1).get<float>());
+    }
+    return values;
+}
+
+auto collection(const Json& source) -> ipc::PreprocessedCollection {
+    ipc::PreprocessedCollection result;
+    result.collection_id = source.at("id");
+    result.monotonic_ns = source.at("timestamp");
+    for (const auto& entry : source.at("traces")) {
+        ipc::SweepTraceBlock trace;
+        trace.combo = {entry.at("input"), entry.at("output")};
+        trace.capture_start_ns = entry.at("start");
+        trace.capture_end_ns = entry.at("end");
+        trace.frequency_hz = entry.at("frequency").get<std::vector<float>>();
+        for (const auto& sample : complex_samples(entry.at("s21"))) {
+            trace.s21.push_back({sample.real(), sample.imag()});
+        }
+        if (result.traces.empty() || trace.capture_start_ns < result.capture_start_ns) {
+            result.capture_start_ns = trace.capture_start_ns;
+        }
+        result.capture_end_ns = std::max(result.capture_end_ns, trace.capture_end_ns);
+        result.traces.push_back(std::move(trace));
+    }
+    return result;
+}
+}
+
+// Runs GPR or sar3d on one request or a batch, retaining processor caches. Each request holds the antenna
+// geometry, the live settings and the latest and previous collections; the
+// published payloads go to stdout as JSON.
+int main() {
+    try {
+        const Json source = Json::parse(std::cin);
+        const bool batch = source.is_array();
+        const Json requests = batch ? source : Json::array({source});
+        Json results = Json::array();
+        processing::Sar3dProcessor sar;
+        processing::GprProcessor gpr;
+        for (const auto& input : requests) {
+            config::RunConfig config;
+            config.rings.results.slot_size_bytes = input.value("slot", config.rings.results.slot_size_bytes);
+            for (const auto& row : input.at("tx")) {
+                config.gpr.tx_geometry.push_back({row.at(0), row.at(1), row.at(2), row.at(3)});
+            }
+            for (const auto& row : input.at("rx")) {
+                config.gpr.rx_geometry.push_back({row.at(0), row.at(1), row.at(2), row.at(3)});
+            }
+            processing::ProcessingLiveConfig live;
+            live.gpr_start_freq_mhz = input.at("f_start").get<double>() / 1e6;
+            live.gpr_stop_freq_mhz = input.at("f_stop").get<double>() / 1e6;
+            live.gpr_min_depth_m = input.at("min_depth");
+            live.gpr_max_depth_m = input.at("max_depth");
+            live.gpr_speed_m_s = input.at("speed");
+            live.gpr_look_angle_deg = input.at("pitch");
+            live.sar3d_voxel_m = input.at("voxel");
+            live.sar3d_bp_ground_depth_m = input.at("ground");
+            live.sar3d_frame_radius = input.at("radius");
+            live.sar3d_comp_range_power = input.at("power");
+            live.sar3d_use_compensation = input.at("compensation");
+            live.sar3d_normalize_each_frame = input.at("normalize");
+            live.pair_depth_equalize = input.value("equalize", true);
+            live.gpr_background_subtract_enabled = input.value("subtract_mean", false);
+            live.gpr_background_mean_count = input.value("mean_count", 10U);
+            live.sar3d_x_size_m = input.value("x_size", 0.0F);
+            live.sar3d_y_min_m = input.value("y_min", -0.5F);
+            live.sar3d_y_max_m = input.value("y_max", 2.0F);
+            live.sar3d_z_size_m = input.value("z_size", 0.0F);
+            live.gpr_bp_ground_depth_m = input.at("ground");
+            live.gpr_range_comp_power = input.at("power");
+            live.gpr_motion_mode = input.value("motion", "int_minus");
+            live.gpr_object_approach_min_frames = 1;
+            live.gpr_remove_sidelobe_objects_enabled = false;
+            std::vector<ipc::PreprocessedCollection> previous;
+            for (const auto& member : input.at("previous")) {
+                previous.push_back(collection(member));
+            }
+            const auto latest = collection(input.at("latest"));
+            for (const auto& trace : latest.traces) { config.run_combos.push_back(trace.combo); }
+            processing::ProcessorInterface& processor = input.value("mode", "sar3d") == "gpr"
+                ? static_cast<processing::ProcessorInterface&>(gpr) : static_cast<processing::ProcessorInterface&>(sar);
+            const auto result = processor.process_collection(config, latest, previous, live);
+            Json payloads = Json::array();
+            for (const auto& payload : result.collection_payloads) {
+                payloads.push_back({{"name", payload.processing_name},
+                    {"x", payload.image_x_axis}, {"y", payload.image_y_axis},
+                    {"image", payload.image_values}, {"table", payload.table_values},
+                    {"columns", payload.table_columns}});
+            }
+            results.push_back(Json{{"payloads", payloads}});
+        }
+        std::cout << (batch ? results : results.at(0)) << '\n';
+    } catch (const std::exception& error) {
+        std::cout << Json{{"error", error.what()}} << '\n';
+        return 1;
+    }
+}