add new old fourier

rfg_adc_plotter/state/ring_buffer.py

@@ -17,6 +17,7 @@ class RingBuffer:
     def __init__(self, max_sweeps: int):
         self.max_sweeps = int(max_sweeps)
         self.fft_bins = FFT_LEN // 2 + 1
+        self.fft_symmetric = True
         self.width = 0
         self.head = 0
         self.ring: Optional[np.ndarray] = None
@@ -25,6 +26,7 @@ class RingBuffer:
         self.x_shared: Optional[np.ndarray] = None
         self.distance_axis: Optional[np.ndarray] = None
         self.last_fft_db: Optional[np.ndarray] = None
+        self.last_freqs: Optional[np.ndarray] = None
         self.y_min_fft: Optional[float] = None
         self.y_max_fft: Optional[float] = None
 
@@ -61,6 +63,50 @@ class RingBuffer:
             changed = True
         return changed
 
+    def set_symmetric_fft_enabled(self, enabled: bool) -> bool:
+        """Switch FFT mode and rebuild cached FFT rows from stored sweeps."""
+        enabled_bool = bool(enabled)
+        if enabled_bool == self.fft_symmetric:
+            return False
+
+        self.fft_symmetric = enabled_bool
+        self.y_min_fft = None
+        self.y_max_fft = None
+
+        if self.ring is None or self.ring_fft is None:
+            return True
+
+        self.ring_fft.fill(np.nan)
+        for row_idx in range(self.ring.shape[0]):
+            sweep_row = self.ring[row_idx]
+            if not np.any(np.isfinite(sweep_row)):
+                continue
+            fft_mag = compute_fft_mag_row(
+                sweep_row,
+                self.last_freqs,
+                self.fft_bins,
+                symmetric=self.fft_symmetric,
+            )
+            self.ring_fft[row_idx, :] = fft_mag
+
+        if self.last_freqs is not None:
+            self.distance_axis = compute_distance_axis(
+                self.last_freqs,
+                self.fft_bins,
+                symmetric=self.fft_symmetric,
+            )
+
+        last_idx = (self.head - 1) % self.max_sweeps
+        if self.ring_fft.shape[0] > 0:
+            last_fft = self.ring_fft[last_idx]
+            self.last_fft_db = fft_mag_to_db(last_fft)
+            finite = self.ring_fft[np.isfinite(self.ring_fft)]
+            if finite.size > 0:
+                finite_db = fft_mag_to_db(finite.astype(np.float32, copy=False))
+                self.y_min_fft = float(np.nanmin(finite_db))
+                self.y_max_fft = float(np.nanmax(finite_db))
+        return True
+
     def push(self, sweep: np.ndarray, freqs: Optional[np.ndarray] = None) -> None:
         """Push a processed sweep and refresh raw/FFT buffers."""
         if sweep is None or sweep.size == 0:
@@ -74,8 +120,10 @@ class RingBuffer:
         row[:take] = np.asarray(sweep[:take], dtype=np.float32)
         self.ring[self.head, :] = row
         self.ring_time[self.head] = time.time()
+        if freqs is not None:
+            self.last_freqs = np.asarray(freqs, dtype=np.float64).copy()
 
-        fft_mag = compute_fft_mag_row(sweep, freqs, self.fft_bins)
+        fft_mag = compute_fft_mag_row(sweep, freqs, self.fft_bins, symmetric=self.fft_symmetric)
         self.ring_fft[self.head, :] = fft_mag
         self.last_fft_db = fft_mag_to_db(fft_mag)
 
@@ -85,7 +133,7 @@ class RingBuffer:
             self.y_min_fft = fr_min if self.y_min_fft is None else min(self.y_min_fft, fr_min)
             self.y_max_fft = fr_max if self.y_max_fft is None else max(self.y_max_fft, fr_max)
 
-        self.distance_axis = compute_distance_axis(freqs, self.fft_bins)
+        self.distance_axis = compute_distance_axis(freqs, self.fft_bins, symmetric=self.fft_symmetric)
         self.head = (self.head + 1) % self.max_sweeps
 
     def get_display_raw(self) -> np.ndarray: