ChTheo/RFG_stm32_ADC_receiver_GUI
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Merge branch 'normaliser'

Browse Source
This commit is contained in:
awe
2026-02-10 20:43:44 +03:00
parent 0332ebdd98 3074859793
commit 77b9ce9615
1 changed files with 291 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

335
RFG_ADC_dataplotter.py
View File

@ -4,7 +4,7 @@
Формат строк:
- "Sweep_start" — начало нового свипа (предыдущий считается завершённым)
- "s X Y" — точка (индекс X, значение Y), все целые со знаком
- "s CH X Y" — точка (номер канала, индекс X, значение Y), все целые со знаком
Отрисовываются два графика:
- Левый: последний полученный свип (Y vs X)
@ -38,7 +38,7 @@ FFT_LEN = 1024 # длина БПФ для спектра/водопада сп
DATA_INVERSION_THRASHOLD = 10.0
Number = Union[int, float]
SweepInfo = Dict[str, Number]
SweepInfo = Dict[str, Any]
SweepPacket = Tuple[np.ndarray, SweepInfo]
@ -312,9 +312,11 @@ class SweepReader(threading.Thread):
self._read_errors: int = 0 # Ошибок чтения из порта
self._last_diag_time: float = 0.0 # Время последнего вывода диагностики
def _finalize_current(self, xs, ys):
def _finalize_current(self, xs, ys, channels: Optional[set[int]]):
if not xs:
return
ch_list = sorted(channels) if channels else [0]
ch_primary = ch_list[0] if ch_list else 0
max_x = max(xs)
width = max_x + 1
self._max_width = max(self._max_width, width)
@ -361,10 +363,14 @@ class SweepReader(threading.Thread):
sweep *= -1.0
except Exception:
pass
sweep -= float(np.nanmean(sweep))
#sweep -= float(np.nanmean(sweep))
# Метрики для статусной строки (вид словаря: переменная -> значение)
self._sweep_idx += 1
if len(ch_list) > 1:
sys.stderr.write(
f"[warn] Sweep {self._sweep_idx}: изменялся номер канала: {ch_list}\n"
)
now = time.time()
if self._last_sweep_ts is None:
dt_ms = float("nan")
@ -388,6 +394,8 @@ class SweepReader(threading.Thread):
vmin = vmax = mean = std = float("nan")
info: SweepInfo = {
"sweep": self._sweep_idx,
"ch": ch_primary,
"chs": ch_list,
"n_valid": n_valid,
"min": vmin,
"max": vmax,
@ -432,6 +440,8 @@ class SweepReader(threading.Thread):
# Состояние текущего свипа
xs: list[int] = []
ys: list[int] = []
cur_channel: Optional[int] = None
cur_channels: set[int] = set()
try:
self._src = SerialLineSource(self._port_path, self._baud, timeout=1.0)
@ -474,21 +484,38 @@ class SweepReader(threading.Thread):
continue
if line.startswith(b"Sweep_start"):
self._finalize_current(xs, ys)
self._finalize_current(xs, ys, cur_channels)
xs.clear()
ys.clear()
cur_channel = None
cur_channels.clear()
continue
# s X Y (оба целые со знаком). Разделяем по любым пробелам/табам.
# sCH X Y или s CH X Y (все целые со знаком). Разделяем по любым пробелам/табам.
if len(line) >= 3:
parts = line.split()
if len(parts) >= 3 and parts[0].lower() == b"s":
if len(parts) >= 3 and (parts[0].lower() == b"s" or parts[0].lower().startswith(b"s")):
try:
x = int(parts[1], 10)
y = int(parts[2], 10) # поддержка знака: "+…" и "-…"
if parts[0].lower() == b"s":
if len(parts) >= 4:
ch = int(parts[1], 10)
x = int(parts[2], 10)
y = int(parts[3], 10) # поддержка знака: "+…" и "-…"
else:
ch = 0
x = int(parts[1], 10)
y = int(parts[2], 10) # поддержка знака: "+…" и "-…"
else:
# формат вида "s0"
ch = int(parts[0][1:], 10)
x = int(parts[1], 10)
y = int(parts[2], 10) # поддержка знака: "+…" и "-…"
except Exception:
self._total_parse_errors += 1
continue
if cur_channel is None:
cur_channel = ch
cur_channels.add(ch)
xs.append(x)
ys.append(y)
self._total_lines_received += 1
@ -505,7 +532,7 @@ class SweepReader(threading.Thread):
finally:
try:
# Завершаем оставшийся свип
self._finalize_current(xs, ys)
self._finalize_current(xs, ys, cur_channels)
except Exception:
pass
try:
@ -638,6 +665,15 @@ def main():
"Напр. 2,98. 'off' — отключить"
),
)
parser.add_argument(
"--spec-mean-sec",
type=float,
default=0.0,
help=(
"Вычитание среднего по каждой частоте за последние N секунд "
"в водопаде спектров (0 — отключить)"
),
)
parser.add_argument("--title", default="ADC Sweeps", help="Заголовок окна")
parser.add_argument(
"--fancy",
@ -673,7 +709,7 @@ def main():
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from matplotlib.widgets import Slider
from matplotlib.widgets import Slider, CheckButtons
except Exception as e:
sys.stderr.write(f"[error] Нужны matplotlib и ее зависимости: {e}\n")
sys.exit(1)
@ -692,7 +728,9 @@ def main():
fig.subplots_adjust(wspace=0.25, hspace=0.35, left=0.07, right=0.90, top=0.95, bottom=0.05)
# Состояние для отображения
current_sweep: Optional[np.ndarray] = None
current_sweep_raw: Optional[np.ndarray] = None
current_sweep_norm: Optional[np.ndarray] = None
last_calib_sweep: Optional[np.ndarray] = None
current_info: Optional[SweepInfo] = None
x_shared: Optional[np.ndarray] = None
width: Optional[int] = None
@ -713,10 +751,13 @@ def main():
y_min_phase, y_max_phase = None, None
# Параметры контраста водопада спектров
spec_clip = _parse_spec_clip(getattr(args, "spec_clip", None))
spec_mean_sec = float(getattr(args, "spec_mean_sec", 0.0))
# Ползунки управления Y для B-scan и контрастом
ymin_slider = None
ymax_slider = None
contrast_slider = None
calib_enabled = False
cb = None
# Статусная строка (внизу окна)
status_text = fig.text(
@ -730,10 +771,22 @@ def main():
)
# Линейный график последнего свипа
line_obj, = ax_line.plot([], [], lw=1)
line_obj, = ax_line.plot([], [], lw=1, color="tab:blue")
line_calib_obj, = ax_line.plot([], [], lw=1, color="tab:red")
line_norm_obj, = ax_line.plot([], [], lw=1, color="tab:green")
ax_line.set_title("Сырые данные", pad=1)
ax_line.set_xlabel("F")
ax_line.set_ylabel("")
channel_text = ax_line.text(
0.98,
0.98,
"",
transform=ax_line.transAxes,
ha="right",
va="top",
fontsize=9,
family="monospace",
)
# Линейный график спектра текущего свипа
fft_line_obj, = ax_fft.plot([], [], lw=1)
@ -786,6 +839,27 @@ def main():
ax_spec.tick_params(axis="x", labelbottom=False)
except Exception:
pass
def _normalize_sweep(raw: np.ndarray, calib: np.ndarray) -> np.ndarray:
w = min(raw.size, calib.size)
if w <= 0:
return raw
out = np.full_like(raw, np.nan, dtype=np.float32)
with np.errstate(divide="ignore", invalid="ignore"):
out[:w] = raw[:w] / calib[:w]
out = np.nan_to_num(out, nan=np.nan, posinf=np.nan, neginf=np.nan)
return out
def _set_calib_enabled():
nonlocal calib_enabled, current_sweep_norm
try:
calib_enabled = bool(cb.get_status()[0]) if cb is not None else False
except Exception:
calib_enabled = False
if calib_enabled and current_sweep_raw is not None and last_calib_sweep is not None:
current_sweep_norm = _normalize_sweep(current_sweep_raw, last_calib_sweep)
else:
current_sweep_norm = None
# График фазы текущего свипа
phase_line_obj, = ax_phase.plot([], [], lw=1)
@ -818,9 +892,11 @@ def main():
ax_smin = fig.add_axes([0.92, 0.55, 0.02, 0.35])
ax_smax = fig.add_axes([0.95, 0.55, 0.02, 0.35])
ax_sctr = fig.add_axes([0.98, 0.55, 0.02, 0.35])
ax_cb = fig.add_axes([0.92, 0.45, 0.08, 0.08])
ymin_slider = Slider(ax_smin, "Y min", 0, max(1, fft_bins - 1), valinit=0, valstep=1, orientation="vertical")
ymax_slider = Slider(ax_smax, "Y max", 0, max(1, fft_bins - 1), valinit=max(1, fft_bins - 1), valstep=1, orientation="vertical")
contrast_slider = Slider(ax_sctr, "Int max", 0, 100, valinit=100, valstep=1, orientation="vertical")
cb = CheckButtons(ax_cb, ["калибровка"], [False])
def _on_ylim_change(_val):
try:
@ -835,6 +911,7 @@ def main():
ymax_slider.on_changed(_on_ylim_change)
# Контраст влияет на верхнюю границу цветовой шкалы (процент от авто-диапазона)
contrast_slider.on_changed(lambda _v: fig.canvas.draw_idle())
cb.on_clicked(lambda _v: _set_calib_enabled())
except Exception:
pass
@ -843,6 +920,7 @@ def main():
interval_ms = int(1000.0 / max_fps)
frames_since_ylim_update = 0
def ensure_buffer(_w: int):
nonlocal ring, width, head, x_shared, ring_fft, freq_shared, ring_time
nonlocal ring_phase, prev_phase_per_bin, phase_offset_per_bin
@ -980,7 +1058,7 @@ def main():
y_max_phase = float(ph_max)
def drain_queue():
nonlocal current_sweep, current_info
nonlocal current_sweep_raw, current_sweep_norm, current_info, last_calib_sweep
drained = 0
while True:
try:
@ -988,10 +1066,26 @@ def main():
except Empty:
break
drained += 1
current_sweep = s
current_sweep_raw = s
current_info = info
ch = 0
try:
ch = int(info.get("ch", 0)) if isinstance(info, dict) else 0
except Exception:
ch = 0
if ch == 0:
last_calib_sweep = s
current_sweep_norm = None
sweep_for_proc = s
else:
if calib_enabled and last_calib_sweep is not None:
current_sweep_norm = _normalize_sweep(s, last_calib_sweep)
sweep_for_proc = current_sweep_norm
else:
current_sweep_norm = None
sweep_for_proc = s
ensure_buffer(s.size)
push_sweep(s)
push_sweep(sweep_for_proc)
return drained
def make_display_ring():
@ -1007,6 +1101,24 @@ def main():
base_t = ring_time if head == 0 else np.roll(ring_time, -head)
return base_t
def _subtract_recent_mean_fft(disp_fft: np.ndarray) -> np.ndarray:
"""Вычесть среднее по каждой частоте за последние spec_mean_sec секунд."""
if spec_mean_sec <= 0.0:
return disp_fft
disp_times = make_display_times()
if disp_times is None:
return disp_fft
now_t = time.time()
mask = np.isfinite(disp_times) & (disp_times >= (now_t - spec_mean_sec))
if not np.any(mask):
return disp_fft
try:
mean_spec = np.nanmean(disp_fft[:, mask], axis=1)
except Exception:
return disp_fft
mean_spec = np.nan_to_num(mean_spec, nan=0.0)
return disp_fft - mean_spec[:, None]
def make_display_ring_fft():
if ring_fft is None:
return np.zeros((1, 1), dtype=np.float32)
@ -1024,18 +1136,26 @@ def main():
changed = drain_queue() > 0
# Обновление линии последнего свипа
if current_sweep is not None:
if x_shared is not None and current_sweep.size <= x_shared.size:
xs = x_shared[: current_sweep.size]
if current_sweep_raw is not None:
if x_shared is not None and current_sweep_raw.size <= x_shared.size:
xs = x_shared[: current_sweep_raw.size]
else:
xs = np.arange(current_sweep.size, dtype=np.int32)
line_obj.set_data(xs, current_sweep)
xs = np.arange(current_sweep_raw.size, dtype=np.int32)
line_obj.set_data(xs, current_sweep_raw)
if last_calib_sweep is not None:
line_calib_obj.set_data(xs[: last_calib_sweep.size], last_calib_sweep)
else:
line_calib_obj.set_data([], [])
if current_sweep_norm is not None:
line_norm_obj.set_data(xs[: current_sweep_norm.size], current_sweep_norm)
else:
line_norm_obj.set_data([], [])
# Лимиты по X постоянные под текущую ширину
ax_line.set_xlim(0, max(1, current_sweep.size - 1))
ax_line.set_xlim(0, max(1, current_sweep_raw.size - 1))
# Адаптивные Y-лимиты (если не задан --ylim)
if fixed_ylim is None:
y0 = float(np.nanmin(current_sweep))
y1 = float(np.nanmax(current_sweep))
y0 = float(np.nanmin(current_sweep_raw))
y1 = float(np.nanmax(current_sweep_raw))
if np.isfinite(y0) and np.isfinite(y1):
if y0 == y1:
pad = max(1.0, abs(y0) * 0.05)
@ -1047,11 +1167,12 @@ def main():
y1 += pad
ax_line.set_ylim(y0, y1)
# Обновление спектра и фазы текущего свипа
take_fft = min(int(current_sweep.size), FFT_LEN)
# Обновление спектра текущего свипа
sweep_for_fft = current_sweep_norm if current_sweep_norm is not None else current_sweep_raw
take_fft = min(int(sweep_for_fft.size), FFT_LEN)
if take_fft > 0 and freq_shared is not None:
fft_in = np.zeros((FFT_LEN,), dtype=np.float32)
seg = np.nan_to_num(current_sweep[:take_fft], nan=0.0).astype(np.float32, copy=False)
seg = np.nan_to_num(sweep_for_fft[:take_fft], nan=0.0).astype(np.float32, copy=False)
win = np.hanning(take_fft).astype(np.float32)
fft_in[:take_fft] = seg * win
spec = np.fft.rfft(fft_in)
@ -1101,6 +1222,7 @@ def main():
# Обновление водопада спектров
if changed and ring_fft is not None:
disp_fft = make_display_ring_fft()
disp_fft = _subtract_recent_mean_fft(disp_fft)
# Новые данные справа: без реверса
img_fft_obj.set_data(disp_fft)
# Подписи времени не обновляем динамически (оставляем авто-тики)
@ -1153,9 +1275,33 @@ def main():
if changed and current_info:
status_text.set_text(_format_status_kv(current_info))
chs = current_info.get("chs") if isinstance(current_info, dict) else None
if chs is None:
chs = current_info.get("ch") if isinstance(current_info, dict) else None
if chs is None:
channel_text.set_text("")
else:
try:
if isinstance(chs, (list, tuple, set)):
ch_list = sorted(int(v) for v in chs)
ch_text_val = ", ".join(str(v) for v in ch_list)
else:
ch_text_val = str(int(chs))
channel_text.set_text(f"chs {ch_text_val}")
except Exception:
channel_text.set_text(f"chs {chs}")
# Возвращаем обновлённые артисты
return (line_obj, img_obj, fft_line_obj, img_fft_obj, phase_line_obj, img_phase_obj, status_text)
return (
line_obj,
line_calib_obj,
line_norm_obj,
img_obj,
fft_line_obj,
img_fft_obj,
status_text,
channel_text,
)
ani = FuncAnimation(fig, update, interval=interval_ms, blit=False)
@ -1201,8 +1347,13 @@ def run_pyqtgraph(args):
p_line = win.addPlot(row=0, col=0, title="Сырые данные")
p_line.showGrid(x=True, y=True, alpha=0.3)
curve = p_line.plot(pen=pg.mkPen((80, 120, 255), width=1))
curve_calib = p_line.plot(pen=pg.mkPen((220, 60, 60), width=1))
curve_norm = p_line.plot(pen=pg.mkPen((60, 180, 90), width=1))
p_line.setLabel("bottom", "X")
p_line.setLabel("left", "Y")
ch_text = pg.TextItem("", anchor=(1, 1))
ch_text.setZValue(10)
p_line.addItem(ch_text)
# Водопад (справа-сверху)
p_img = win.addPlot(row=0, col=1, title="Сырые данные водопад")
@ -1237,6 +1388,12 @@ def run_pyqtgraph(args):
img_fft = pg.ImageItem()
p_spec.addItem(img_fft)
# Чекбокс калибровки
calib_cb = QtWidgets.QCheckBox("калибровка")
cb_proxy = QtWidgets.QGraphicsProxyWidget()
cb_proxy.setWidget(calib_cb)
win.addItem(cb_proxy, row=2, col=1)
# График фазы (слева-снизу)
p_phase = win.addPlot(row=2, col=0, title="Фаза спектра (развернутая)")
p_phase.showGrid(x=True, y=True, alpha=0.3)
@ -1280,10 +1437,13 @@ def run_pyqtgraph(args):
# Состояние
ring: Optional[np.ndarray] = None
ring_time: Optional[np.ndarray] = None
head = 0
width: Optional[int] = None
x_shared: Optional[np.ndarray] = None
current_sweep: Optional[np.ndarray] = None
current_sweep_raw: Optional[np.ndarray] = None
current_sweep_norm: Optional[np.ndarray] = None
last_calib_sweep: Optional[np.ndarray] = None
current_info: Optional[SweepInfo] = None
# Авто-уровни цветовой шкалы водопада сырых данных пересчитываются по видимой области.
# Для спектров
@ -1298,6 +1458,8 @@ def run_pyqtgraph(args):
y_min_phase, y_max_phase = None, None
# Параметры контраста водопада спектров (процентильная обрезка)
spec_clip = _parse_spec_clip(getattr(args, "spec_clip", None))
spec_mean_sec = float(getattr(args, "spec_mean_sec", 0.0))
calib_enabled = False
# Диапазон по Y: авто по умолчанию (поддерживает отрицательные значения)
fixed_ylim: Optional[Tuple[float, float]] = None
if args.ylim:
@ -1309,14 +1471,41 @@ def run_pyqtgraph(args):
if fixed_ylim is not None:
p_line.setYRange(fixed_ylim[0], fixed_ylim[1], padding=0)
def _normalize_sweep(raw: np.ndarray, calib: np.ndarray) -> np.ndarray:
w = min(raw.size, calib.size)
if w <= 0:
return raw
out = np.full_like(raw, np.nan, dtype=np.float32)
with np.errstate(divide="ignore", invalid="ignore"):
out[:w] = raw[:w] / calib[:w]
out = np.nan_to_num(out, nan=np.nan, posinf=np.nan, neginf=np.nan)
return out
def _set_calib_enabled():
nonlocal calib_enabled, current_sweep_norm
try:
calib_enabled = bool(calib_cb.isChecked())
except Exception:
calib_enabled = False
if calib_enabled and current_sweep_raw is not None and last_calib_sweep is not None:
current_sweep_norm = _normalize_sweep(current_sweep_raw, last_calib_sweep)
else:
current_sweep_norm = None
try:
calib_cb.stateChanged.connect(lambda _v: _set_calib_enabled())
except Exception:
pass
def ensure_buffer(_w: int):
nonlocal ring, head, width, x_shared, ring_fft, freq_shared
nonlocal ring, ring_time, head, width, x_shared, ring_fft, freq_shared
nonlocal ring_phase, prev_phase_per_bin, phase_offset_per_bin
if ring is not None:
return
width = WF_WIDTH
x_shared = np.arange(width, dtype=np.int32)
ring = np.full((max_sweeps, width), np.nan, dtype=np.float32)
ring_time = np.full((max_sweeps,), np.nan, dtype=np.float64)
head = 0
# Водопад: время по оси X, X по оси Y
img.setImage(ring.T, autoLevels=False)
@ -1368,7 +1557,7 @@ def run_pyqtgraph(args):
return (vmin, vmax)
def push_sweep(s: np.ndarray):
nonlocal ring, head, ring_fft, y_min_fft, y_max_fft
nonlocal ring, ring_time, head, ring_fft, y_min_fft, y_max_fft
nonlocal ring_phase, prev_phase_per_bin, phase_offset_per_bin, y_min_phase, y_max_phase
if s is None or s.size == 0 or ring is None:
return
@ -1377,6 +1566,8 @@ def run_pyqtgraph(args):
take = min(w, s.size)
row[:take] = s[:take]
ring[head, :] = row
if ring_time is not None:
ring_time[head] = time.time()
head = (head + 1) % ring.shape[0]
# FFT строка (дБ) и фаза
if ring_fft is not None:
@ -1428,7 +1619,7 @@ def run_pyqtgraph(args):
y_max_phase = float(ph_max)
def drain_queue():
nonlocal current_sweep, current_info
nonlocal current_sweep_raw, current_sweep_norm, current_info, last_calib_sweep
drained = 0
while True:
try:
@ -1436,10 +1627,26 @@ def run_pyqtgraph(args):
except Empty:
break
drained += 1
current_sweep = s
current_sweep_raw = s
current_info = info
ch = 0
try:
ch = int(info.get("ch", 0)) if isinstance(info, dict) else 0
except Exception:
ch = 0
if ch == 0:
last_calib_sweep = s
current_sweep_norm = None
sweep_for_proc = s
else:
if calib_enabled and last_calib_sweep is not None:
current_sweep_norm = _normalize_sweep(s, last_calib_sweep)
sweep_for_proc = current_sweep_norm
else:
current_sweep_norm = None
sweep_for_proc = s
ensure_buffer(s.size)
push_sweep(s)
push_sweep(sweep_for_proc)
return drained
# Попытка применить LUT из колормэпа (если доступен)
@ -1453,24 +1660,33 @@ def run_pyqtgraph(args):
def update():
changed = drain_queue() > 0
if current_sweep is not None and x_shared is not None:
if current_sweep.size <= x_shared.size:
xs = x_shared[: current_sweep.size]
if current_sweep_raw is not None and x_shared is not None:
if current_sweep_raw.size <= x_shared.size:
xs = x_shared[: current_sweep_raw.size]
else:
xs = np.arange(current_sweep.size)
curve.setData(xs, current_sweep, autoDownsample=True)
xs = np.arange(current_sweep_raw.size)
curve.setData(xs, current_sweep_raw, autoDownsample=True)
if last_calib_sweep is not None:
curve_calib.setData(xs[: last_calib_sweep.size], last_calib_sweep, autoDownsample=True)
else:
curve_calib.setData([], [])
if current_sweep_norm is not None:
curve_norm.setData(xs[: current_sweep_norm.size], current_sweep_norm, autoDownsample=True)
else:
curve_norm.setData([], [])
if fixed_ylim is None:
y0 = float(np.nanmin(current_sweep))
y1 = float(np.nanmax(current_sweep))
y0 = float(np.nanmin(current_sweep_raw))
y1 = float(np.nanmax(current_sweep_raw))
if np.isfinite(y0) and np.isfinite(y1):
margin = 0.05 * max(1.0, (y1 - y0))
p_line.setYRange(y0 - margin, y1 + margin, padding=0)
# Обновим спектр и фазу
take_fft = min(int(current_sweep.size), FFT_LEN)
# Обновим спектр
sweep_for_fft = current_sweep_norm if current_sweep_norm is not None else current_sweep_raw
take_fft = min(int(sweep_for_fft.size), FFT_LEN)
if take_fft > 0 and freq_shared is not None:
fft_in = np.zeros((FFT_LEN,), dtype=np.float32)
seg = np.nan_to_num(current_sweep[:take_fft], nan=0.0).astype(np.float32, copy=False)
seg = np.nan_to_num(sweep_for_fft[:take_fft], nan=0.0).astype(np.float32, copy=False)
win = np.hanning(take_fft).astype(np.float32)
fft_in[:take_fft] = seg * win
spec = np.fft.rfft(fft_in)
@ -1514,10 +1730,41 @@ def run_pyqtgraph(args):
status.setText(_format_status_kv(current_info))
except Exception:
pass
try:
chs = current_info.get("chs") if isinstance(current_info, dict) else None
if chs is None:
chs = current_info.get("ch") if isinstance(current_info, dict) else None
if chs is None:
ch_text.setText("")
else:
if isinstance(chs, (list, tuple, set)):
ch_list = sorted(int(v) for v in chs)
ch_text_val = ", ".join(str(v) for v in ch_list)
else:
ch_text_val = str(int(chs))
ch_text.setText(f"chs {ch_text_val}")
(x0, x1), (y0, y1) = p_line.viewRange()
dx = 0.01 * max(1.0, float(x1 - x0))
dy = 0.01 * max(1.0, float(y1 - y0))
ch_text.setPos(float(x1 - dx), float(y1 - dy))
except Exception:
pass
if changed and ring_fft is not None:
disp_fft = ring_fft if head == 0 else np.roll(ring_fft, -head, axis=0)
disp_fft = disp_fft.T[:, ::-1]
if spec_mean_sec > 0.0 and ring_time is not None:
disp_times = ring_time if head == 0 else np.roll(ring_time, -head)
disp_times = disp_times[::-1]
now_t = time.time()
mask = np.isfinite(disp_times) & (disp_times >= (now_t - spec_mean_sec))
if np.any(mask):
try:
mean_spec = np.nanmean(disp_fft[:, mask], axis=1)
mean_spec = np.nan_to_num(mean_spec, nan=0.0)
disp_fft = disp_fft - mean_spec[:, None]
except Exception:
pass
# Автодиапазон по среднему спектру за видимый интервал (как в хорошей версии)
levels = None
try: