fix graph and white background added

data_acq_and_processing/processing/processors/src/bscan_processor.cpp

@@ -93,24 +93,9 @@ void fft_inplace(std::vector<std::complex<double>>& values, bool inverse) {
     return std::abs(sample);
 }
 
-[[nodiscard]] auto fallback_profile(
-    const ipc::SweepTraceBlock& trace,
-    std::span<const ipc::Complex32> selected_samples
-) -> BScanProfile {
-    const std::size_t point_count = std::min(trace.frequency_hz.size(), selected_samples.size());
-    BScanProfile fallback{};
-    fallback.depth_m.reserve(point_count);
-    fallback.response.reserve(point_count);
-
-    const float denominator = point_count > 1U ? static_cast<float>(point_count - 1U) : 1.0F;
-    for (std::size_t index = 0U; index < point_count; ++index) {
-        const auto& sample = selected_samples[index];
-        fallback.depth_m.push_back(static_cast<float>(static_cast<float>(index) / denominator));
-        fallback.response.push_back(std::sqrt(sample.re * sample.re + sample.im * sample.im));
-    }
-    return fallback;
-}
-
+// A range profile needs at least two in-band points on an increasing frequency grid.
+// Otherwise the profile is empty and the display leaves the column out: drawing |S21|
+// against a made-up depth axis would look like a valid B-scan.
 [[nodiscard]] auto compute_bscan_profile(
     const ipc::SweepTraceBlock& trace,
     const ProcessingLiveConfig& live_config
@@ -118,7 +103,7 @@ void fft_inplace(std::vector<std::complex<double>>& values, bool inverse) {
     const auto selected_samples = std::span<const ipc::Complex32>(trace.s21);
     const std::size_t point_count = std::min(trace.frequency_hz.size(), selected_samples.size());
     if (point_count < 2U) {
-        return fallback_profile(trace, selected_samples);
+        return {};
     }
 
     const double configured_start_hz = static_cast<double>(live_config.bscan_start_freq_mhz) * 1'000'000.0;
@@ -142,35 +127,35 @@ void fft_inplace(std::vector<std::complex<double>>& values, bool inverse) {
     }
 
     if (filtered_freq_hz.size() < 2U) {
-        return fallback_profile(trace, selected_samples);
+        return {};
     }
 
     const std::size_t filtered_count = filtered_freq_hz.size();
     const double df = (filtered_freq_hz.back() - filtered_freq_hz.front()) / static_cast<double>(filtered_count - 1U);
     if (df <= 0.0) {
-        return fallback_profile(trace, selected_samples);
+        return {};
     }
 
     const auto start_bin = static_cast<std::int64_t>(std::llround(filtered_freq_hz.front() / df));
     if (start_bin < 0) {
-        return fallback_profile(trace, selected_samples);
+        return {};
     }
 
     const auto start_index = static_cast<std::size_t>(start_bin);
     if (start_index > (std::numeric_limits<std::size_t>::max() / 2U)) {
-        return fallback_profile(trace, selected_samples);
+        return {};
     }
     if (start_index > (std::numeric_limits<std::size_t>::max() - filtered_count + 1U)) {
-        return fallback_profile(trace, selected_samples);
+        return {};
     }
 
     const std::size_t min_fft_len = 2U * (start_index + filtered_count - 1U);
     const std::size_t fft_len = next_power_of_two(min_fft_len);
     if (fft_len < min_fft_len || (fft_len & (fft_len - 1U)) != 0U) {
-        return fallback_profile(trace, selected_samples);
+        return {};
     }
     if (start_index > fft_len || filtered_count > (fft_len - start_index)) {
-        return fallback_profile(trace, selected_samples);
+        return {};
     }
 
     std::vector<std::complex<double>> spectrum(fft_len, std::complex<double>(0.0, 0.0));