|
|
|
@ -1,170 +1,258 @@
|
|
|
|
import statistics
|
|
|
|
import os
|
|
|
|
|
|
|
|
import statistics
|
|
|
|
# Более лучшая версия кода есть в FRScanner
|
|
|
|
from datetime import datetime
|
|
|
|
|
|
|
|
|
|
|
|
class DataBuffer:
|
|
|
|
# Более лучшая версия кода есть в FRScanner
|
|
|
|
"""
|
|
|
|
|
|
|
|
Класс с реализацией циклического буффера.
|
|
|
|
|
|
|
|
|
|
|
|
class DataBuffer:
|
|
|
|
Атрибуты:
|
|
|
|
"""
|
|
|
|
current_column: Указатель на текущий столбец буфера, который обновляем.
|
|
|
|
Класс с реализацией циклического буффера.
|
|
|
|
thinning_counter: Прореживающий множитель на текующей итерации.
|
|
|
|
|
|
|
|
current_counter: Указатель на количество чтений между последним обновлением столбца и предыдущим атрибутом.
|
|
|
|
Атрибуты:
|
|
|
|
num_of_thinning_iter: Прореживающий множитель. Раз в это количечество раз будет обнволяться столбец буфера.
|
|
|
|
current_column: Указатель на текущий столбец буфера, который обновляем.
|
|
|
|
line_size: Количество строк буфера = количеству каналов.
|
|
|
|
thinning_counter: Прореживающий множитель на текующей итерации.
|
|
|
|
columns_size: Количество столбцов = фиксированное число.
|
|
|
|
current_counter: Указатель на количество чтений между последним обновлением столбца и предыдущим атрибутом.
|
|
|
|
multiply_factor: Процентный показатель превышения сигналом уровня шума. ex m_p = 1.1 => триггер, если
|
|
|
|
num_of_thinning_iter: Прореживающий множитель. Раз в это количество раз будет обновляться столбец буфера.
|
|
|
|
сигнал превышает шум на 10%.
|
|
|
|
line_size: Количество строк буфера = количеству каналов.
|
|
|
|
num_for_alarm: Количество раз, превышающих шум, при которых триггеримся = фиксированное число.
|
|
|
|
columns_size: Количество столбцов = фиксированное число.
|
|
|
|
is_init: Флаг инициализации буфера. = True, если инициализирован.
|
|
|
|
multiply_factor: Процентный показатель превышения сигналом уровня шума (legacy).
|
|
|
|
buffer: Массив для буфера.
|
|
|
|
num_for_alarm: Количество раз, превышающих шум, при которых триггеримся.
|
|
|
|
buffer_medians: Массив для медиан столбцов букера.
|
|
|
|
is_init: Флаг инициализации буфера.
|
|
|
|
buffer_alarms: Массив для количества тревог по столбца буфера.
|
|
|
|
buffer: Массив для буфера.
|
|
|
|
"""
|
|
|
|
buffer_medians: Массив медиан по каналам.
|
|
|
|
|
|
|
|
buffer_mads: Массив MAD по каналам.
|
|
|
|
def __init__(self, columns_size, num_of_thinning_iter, num_of_channels, multiply_factor, num_for_alarm):
|
|
|
|
buffer_alarms: Массив для количества тревог по каналам.
|
|
|
|
"""
|
|
|
|
"""
|
|
|
|
Инициализируем класс.
|
|
|
|
|
|
|
|
|
|
|
|
def __init__(self, columns_size, num_of_thinning_iter, num_of_channels, multiply_factor, num_for_alarm, freq_tag=None):
|
|
|
|
:param columns_size:
|
|
|
|
self.current_column = 0
|
|
|
|
:param num_of_thinning_iter:
|
|
|
|
self.thinning_counter = 1
|
|
|
|
:param num_of_channels:
|
|
|
|
self.current_counter = 1
|
|
|
|
:param multiply_factor:
|
|
|
|
self.num_of_thinning_iter = num_of_thinning_iter
|
|
|
|
:param num_for_alarm:
|
|
|
|
self.line_size = num_of_channels
|
|
|
|
"""
|
|
|
|
self.columns_size = columns_size
|
|
|
|
self.current_column = 0
|
|
|
|
self.multiply_factor = multiply_factor
|
|
|
|
self.thinning_counter = 1
|
|
|
|
self.num_for_alarm = num_for_alarm
|
|
|
|
self.current_counter = 1
|
|
|
|
self.is_init = False
|
|
|
|
self.num_of_thinning_iter = num_of_thinning_iter
|
|
|
|
|
|
|
|
self.line_size = num_of_channels
|
|
|
|
self.buffer = [[0 for _ in range(self.columns_size)] for _ in range(self.line_size)]
|
|
|
|
self.columns_size = columns_size
|
|
|
|
self.buffer_timestamps = [[None for _ in range(self.columns_size)] for _ in range(self.line_size)]
|
|
|
|
self.multiply_factor = multiply_factor
|
|
|
|
self.buffer_medians = [0.0] * self.line_size
|
|
|
|
self.num_for_alarm = num_for_alarm
|
|
|
|
self.buffer_mads = [0.0] * self.line_size
|
|
|
|
self.is_init = False
|
|
|
|
self.buffer_alarms = [0] * self.line_size
|
|
|
|
self.buffer = [[0 for _ in range(self.columns_size)] for _ in range(self.line_size)]
|
|
|
|
self.last_alarm_channels = []
|
|
|
|
self.buffer_medians = [0] * self.line_size
|
|
|
|
self.episode_history = [[0.0 for _ in range(self.num_of_thinning_iter)] for _ in range(self.line_size)]
|
|
|
|
self.buffer_alarms = [0] * self.line_size
|
|
|
|
self.episode_history_timestamps = [[None for _ in range(self.num_of_thinning_iter)] for _ in range(self.line_size)]
|
|
|
|
|
|
|
|
|
|
|
|
def get_buffer(self):
|
|
|
|
self.freq_tag = '' if freq_tag is None else str(freq_tag)
|
|
|
|
return self.buffer
|
|
|
|
suffix = f'_{self.freq_tag}' if self.freq_tag else ''
|
|
|
|
|
|
|
|
|
|
|
|
def get_medians(self):
|
|
|
|
self.mad_k_on = float(os.getenv('mad_k_on' + suffix, os.getenv('mad_k_on', 5.0)))
|
|
|
|
return self.buffer_medians
|
|
|
|
self.mad_eps = float(os.getenv('mad_eps' + suffix, os.getenv('mad_eps', 0.05)))
|
|
|
|
|
|
|
|
self.dbfs_linear_offset_db = float(
|
|
|
|
def get_alarms(self):
|
|
|
|
os.getenv('dbfs_linear_offset_db' + suffix, os.getenv('dbfs_linear_offset_db', 0.0))
|
|
|
|
return self.buffer_alarms
|
|
|
|
)
|
|
|
|
|
|
|
|
self.dbfs_linear_abs_median_scale = float(
|
|
|
|
def check_init(self):
|
|
|
|
os.getenv('dbfs_linear_abs_median_scale' + suffix, os.getenv('dbfs_linear_abs_median_scale', 0.0))
|
|
|
|
return self.is_init
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
|
def print(self):
|
|
|
|
def get_buffer(self):
|
|
|
|
print('buffer is: ')
|
|
|
|
return self.buffer
|
|
|
|
for i in range(self.line_size):
|
|
|
|
|
|
|
|
print(self.buffer[i], end=' ')
|
|
|
|
def get_timestamps(self):
|
|
|
|
print()
|
|
|
|
return self.buffer_timestamps
|
|
|
|
|
|
|
|
|
|
|
|
def medians(self):
|
|
|
|
def get_medians(self):
|
|
|
|
"""
|
|
|
|
return self.buffer_medians
|
|
|
|
Вычислить медиану по строке буфера.
|
|
|
|
|
|
|
|
:return: None
|
|
|
|
def get_mads(self):
|
|
|
|
"""
|
|
|
|
return self.buffer_mads
|
|
|
|
if self.check_init():
|
|
|
|
|
|
|
|
for i in range(self.line_size):
|
|
|
|
def get_alarms(self):
|
|
|
|
self.buffer_medians[i] = statistics.median(self.buffer[i])
|
|
|
|
return self.buffer_alarms
|
|
|
|
# print('medians is: ', self.buffer_medians)
|
|
|
|
|
|
|
|
# return self.buffer_medians
|
|
|
|
def get_last_alarm_channels(self):
|
|
|
|
|
|
|
|
return list(self.last_alarm_channels)
|
|
|
|
def alarms_fill_zeros(self):
|
|
|
|
|
|
|
|
self.buffer_alarms = [0] * self.line_size
|
|
|
|
def check_init(self):
|
|
|
|
def update(self, data):
|
|
|
|
return self.is_init
|
|
|
|
"""
|
|
|
|
|
|
|
|
Обновление буфера.
|
|
|
|
def print(self):
|
|
|
|
Если номер текущего чтения совпадает с количеством прореживающего множителя на текущем обновлении буфера, то
|
|
|
|
print('buffer is: ')
|
|
|
|
1. Обновляем буфер.
|
|
|
|
for i in range(self.line_size):
|
|
|
|
2. Двигаем курсор на след столбец. Если был последний столбец, то двигаем курсор в начало.
|
|
|
|
print(self.buffer[i], end=' ')
|
|
|
|
3. Берем медианы по буферу, если он уже проиницализирован.
|
|
|
|
print()
|
|
|
|
4. Сбрасываем счетчик текущих чтений.
|
|
|
|
|
|
|
|
5. Если был последний столбец (и мы уже переключились на первый), то
|
|
|
|
@staticmethod
|
|
|
|
Если прореживающий множитель на текующей итерации был единица, то мы иницилизировались
|
|
|
|
def _calc_mad(values, median):
|
|
|
|
До тех пор, пока множитель на итерации меньше фиксированного, увеличиваем в два раза.
|
|
|
|
deviations = [abs(v - median) for v in values]
|
|
|
|
В противном случае - увеличиваем номер чтения.
|
|
|
|
return statistics.median(deviations)
|
|
|
|
:param data: Массив с метриками сигнала по каналам.
|
|
|
|
|
|
|
|
:return: None
|
|
|
|
@staticmethod
|
|
|
|
"""
|
|
|
|
def _format_ts(timestamp):
|
|
|
|
|
|
|
|
if timestamp is None:
|
|
|
|
# TODO: Добавить время релаксации - если система затриггерилась, то перестать обновлять буфер на N чтений,
|
|
|
|
return 'None'
|
|
|
|
# где N задается в .env-template. Сейчас есть бага, что буфер перестает обновляться только когда система
|
|
|
|
try:
|
|
|
|
# триггерится. Между тем, когда приходит аларм и num_for_alarm, когда сигнал алармовский, но система еще не
|
|
|
|
return datetime.fromtimestamp(float(timestamp)).isoformat(sep=' ', timespec='milliseconds')
|
|
|
|
# триггерится, буфер продолжает обновляться. В таких условиях буфер может набрать в себя алармовских сигналов
|
|
|
|
except Exception:
|
|
|
|
# и повысить пороги. Пример такой ситуации: дрон висит на 1км, система его видит, но сигнал превышает порог раз
|
|
|
|
return str(timestamp)
|
|
|
|
# через раз и аларм срабатывает не всегда. В таких условиях наберется высокий сигнал, повысятся пороги и когда
|
|
|
|
|
|
|
|
# дрон начнет движение вперед, он будет заметен на более низкой дистанции, чем обычно, так как пороги повышены.
|
|
|
|
@staticmethod
|
|
|
|
|
|
|
|
def _mean_timestamp(timestamps):
|
|
|
|
if self.current_counter == self.thinning_counter:
|
|
|
|
filtered = [float(ts) for ts in timestamps if ts is not None]
|
|
|
|
for i in range(self.line_size):
|
|
|
|
if not filtered:
|
|
|
|
self.buffer[i][self.current_column] = data[i]
|
|
|
|
return None
|
|
|
|
self.current_column = (self.current_column + 1) % self.columns_size
|
|
|
|
return sum(filtered) / len(filtered)
|
|
|
|
#print('Столбец {0} обновлен. Перешли к столбцу {1}: '.format(self.current_column - 1, self.current_column))
|
|
|
|
|
|
|
|
self.medians()
|
|
|
|
def medians(self):
|
|
|
|
self.current_counter = 1
|
|
|
|
"""
|
|
|
|
if self.current_column == 0:
|
|
|
|
Вычислить медиану и MAD по строкам буфера.
|
|
|
|
if self.thinning_counter == 1:
|
|
|
|
:return: None
|
|
|
|
self.is_init = True
|
|
|
|
"""
|
|
|
|
self.medians()
|
|
|
|
if self.check_init():
|
|
|
|
print('Начальная калибровка завершена.')
|
|
|
|
for i in range(self.line_size):
|
|
|
|
if self.thinning_counter < self.num_of_thinning_iter:
|
|
|
|
med = float(statistics.median(self.buffer[i]))
|
|
|
|
self.thinning_counter *= 2
|
|
|
|
self.buffer_medians[i] = med
|
|
|
|
# print('thinning counter обновлен: ', self.thinning_counter)
|
|
|
|
self.buffer_mads[i] = float(self._calc_mad(self.buffer[i], med))
|
|
|
|
|
|
|
|
|
|
|
|
else:
|
|
|
|
def get_linear_term(self, median_value):
|
|
|
|
self.current_counter += 1
|
|
|
|
median_value = float(median_value)
|
|
|
|
# print('curr counter обновлен: ', self.current_counter)
|
|
|
|
return self.dbfs_linear_offset_db + self.dbfs_linear_abs_median_scale * abs(median_value)
|
|
|
|
|
|
|
|
|
|
|
|
def check_alarm(self, data):
|
|
|
|
def get_threshold(self, channel_idx):
|
|
|
|
"""
|
|
|
|
"""
|
|
|
|
Проверка триггера системы.
|
|
|
|
Получить динамический порог в dB для канала:
|
|
|
|
Если значение по каналу превышает медиану (порог) шума на какой-то процент, то инкремент буфер аларма по каналу.
|
|
|
|
threshold = median + linear_term(median) + mad_k_on * MAD.
|
|
|
|
Превышение num_for_alarm подряд - триггер. Если после n превышений, где n<num_for_alarm приходит сигнал не
|
|
|
|
До завершения инициализации возвращает None.
|
|
|
|
первышающий порог, то сбрасываем буфер алармов.
|
|
|
|
"""
|
|
|
|
:param data:
|
|
|
|
if not self.check_init():
|
|
|
|
:return: Да/нет.
|
|
|
|
return None
|
|
|
|
"""
|
|
|
|
|
|
|
|
if self.check_init():
|
|
|
|
baseline = float(self.buffer_medians[channel_idx])
|
|
|
|
ratios=[]
|
|
|
|
mad_eff = max(float(self.buffer_mads[channel_idx]), self.mad_eps)
|
|
|
|
print("="*50)
|
|
|
|
linear_term = self.get_linear_term(baseline)
|
|
|
|
for i in range(len(data)):
|
|
|
|
return baseline + linear_term + self.mad_k_on * mad_eff
|
|
|
|
exceeding = data[i] > self.multiply_factor * self.buffer_medians[i]
|
|
|
|
|
|
|
|
ratios.append(data[i]/self.buffer_medians[i])
|
|
|
|
def get_thresholds(self):
|
|
|
|
if exceeding:
|
|
|
|
if not self.check_init():
|
|
|
|
self.buffer_alarms[i] += 1
|
|
|
|
return [None] * self.line_size
|
|
|
|
# print('Инкремент буффер алармов по каналу {0}, текущее число по этому каналу: {1}'.format(i,self.buffer_alarms[i]))
|
|
|
|
return [self.get_threshold(i) for i in range(self.line_size)]
|
|
|
|
else:
|
|
|
|
|
|
|
|
self.buffer_alarms[i] = 0
|
|
|
|
def log_threshold_update(self, updated_column):
|
|
|
|
# print('Обнулили буффер алармов по каналу {0}, текущее число по этому каналу: {1}'.format(i,self.buffer_alarms[i]))
|
|
|
|
if not self.check_init():
|
|
|
|
|
|
|
|
return
|
|
|
|
if self.buffer_alarms[i] >= self.num_for_alarm:
|
|
|
|
|
|
|
|
# print('Сработала тревога по каналу {0}, текущее число по этому каналу: {1}'.format(i,self.buffer_alarms[i]))
|
|
|
|
now_str = datetime.now().isoformat(sep=' ', timespec='milliseconds')
|
|
|
|
self.buffer_alarms = [0] * self.line_size
|
|
|
|
freq_tag = self.freq_tag or 'unknown'
|
|
|
|
print("Отношения:", [f"{r:.3f}" for r in ratios])
|
|
|
|
print(f'[threshold-update][{freq_tag}] now={now_str} updated_column={updated_column}')
|
|
|
|
print("!"*50)
|
|
|
|
for i in range(self.line_size):
|
|
|
|
return True
|
|
|
|
baseline = float(self.buffer_medians[i])
|
|
|
|
print("Отношения:", [f"{r:.3f}" for r in ratios])
|
|
|
|
mad = float(self.buffer_mads[i])
|
|
|
|
print("="*50)
|
|
|
|
mad_eff = max(mad, self.mad_eps)
|
|
|
|
|
|
|
|
linear_term = self.get_linear_term(baseline)
|
|
|
|
|
|
|
|
threshold = self.get_threshold(i)
|
|
|
|
return False
|
|
|
|
packet_times = [self._format_ts(ts) for ts in self.buffer_timestamps[i]]
|
|
|
|
|
|
|
|
print(
|
|
|
|
def check_single_alarm(self, median, cur_channel):
|
|
|
|
f' ch={i} median={baseline:.6f} '
|
|
|
|
"""
|
|
|
|
f'linear_term={linear_term:.6f} '
|
|
|
|
Проверка, является ли текущая медиана по каналу превышающей порог.
|
|
|
|
f'mad={mad:.6f} mad_eff={mad_eff:.6f} '
|
|
|
|
:param median: меди (хар-ка) по каналу.
|
|
|
|
f'mad_term={self.mad_k_on * mad_eff:.6f} '
|
|
|
|
:param cur_channel: индекс канала внутри частоты.
|
|
|
|
f'threshold={threshold:.6f} '
|
|
|
|
:return: Да/нет.
|
|
|
|
f'packet_times={packet_times}'
|
|
|
|
"""
|
|
|
|
)
|
|
|
|
if self.check_init():
|
|
|
|
|
|
|
|
exceeding = median > self.multiply_factor * self.buffer_medians[cur_channel]
|
|
|
|
def alarms_fill_zeros(self):
|
|
|
|
print(median/self.buffer_medians[cur_channel])
|
|
|
|
self.buffer_alarms = [0] * self.line_size
|
|
|
|
if exceeding:
|
|
|
|
self.last_alarm_channels = []
|
|
|
|
return True
|
|
|
|
|
|
|
|
else:
|
|
|
|
def update(self, data, packet_timestamps=None):
|
|
|
|
return False
|
|
|
|
"""
|
|
|
|
|
|
|
|
Обновление буфера.
|
|
|
|
|
|
|
|
Если номер текущего чтения совпадает с количеством прореживающего множителя на текущем обновлении буфера, то
|
|
|
|
|
|
|
|
1. Обновляем буфер.
|
|
|
|
|
|
|
|
2. Двигаем курсор на след столбец. Если был последний столбец, то двигаем курсор в начало.
|
|
|
|
|
|
|
|
3. Берем медианы по буферу, если он уже проиницализирован.
|
|
|
|
|
|
|
|
4. Сбрасываем счетчик текущих чтений.
|
|
|
|
|
|
|
|
5. Если был последний столбец (и мы уже переключились на первый), то
|
|
|
|
|
|
|
|
Если прореживающий множитель на текующей итерации был единица, то мы иницилизировались.
|
|
|
|
|
|
|
|
До тех пор, пока множитель на итерации меньше фиксированного, увеличиваем в два раза.
|
|
|
|
|
|
|
|
В противном случае - увеличиваем номер чтения.
|
|
|
|
|
|
|
|
:param data: Массив с метриками сигнала по каналам.
|
|
|
|
|
|
|
|
:param packet_timestamps: Времена пакетов SDR для каждой метрики канала.
|
|
|
|
|
|
|
|
:return: None
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
if packet_timestamps is None:
|
|
|
|
|
|
|
|
packet_timestamps = [None] * self.line_size
|
|
|
|
|
|
|
|
if len(packet_timestamps) != self.line_size:
|
|
|
|
|
|
|
|
raise ValueError('packet_timestamps length must match number of channels')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
sample_idx = self.current_counter - 1
|
|
|
|
|
|
|
|
for i in range(self.line_size):
|
|
|
|
|
|
|
|
self.episode_history[i][sample_idx] = float(data[i])
|
|
|
|
|
|
|
|
self.episode_history_timestamps[i][sample_idx] = packet_timestamps[i]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if self.current_counter == self.thinning_counter:
|
|
|
|
|
|
|
|
updated_column = self.current_column
|
|
|
|
|
|
|
|
for i in range(self.line_size):
|
|
|
|
|
|
|
|
samples = self.episode_history[i][:self.thinning_counter]
|
|
|
|
|
|
|
|
timestamps = self.episode_history_timestamps[i][:self.thinning_counter]
|
|
|
|
|
|
|
|
self.buffer[i][self.current_column] = float(sum(samples) / len(samples))
|
|
|
|
|
|
|
|
self.buffer_timestamps[i][self.current_column] = self._mean_timestamp(timestamps)
|
|
|
|
|
|
|
|
self.current_column = (self.current_column + 1) % self.columns_size
|
|
|
|
|
|
|
|
self.medians()
|
|
|
|
|
|
|
|
if self.check_init():
|
|
|
|
|
|
|
|
self.log_threshold_update(updated_column)
|
|
|
|
|
|
|
|
for i in range(self.line_size):
|
|
|
|
|
|
|
|
for j in range(self.thinning_counter):
|
|
|
|
|
|
|
|
self.episode_history[i][j] = 0.0
|
|
|
|
|
|
|
|
self.episode_history_timestamps[i][j] = None
|
|
|
|
|
|
|
|
self.current_counter = 1
|
|
|
|
|
|
|
|
if self.current_column == 0:
|
|
|
|
|
|
|
|
if self.thinning_counter == 1:
|
|
|
|
|
|
|
|
self.is_init = True
|
|
|
|
|
|
|
|
self.medians()
|
|
|
|
|
|
|
|
print('Начальная калибровка завершена.')
|
|
|
|
|
|
|
|
self.log_threshold_update(updated_column)
|
|
|
|
|
|
|
|
if self.thinning_counter < self.num_of_thinning_iter:
|
|
|
|
|
|
|
|
self.thinning_counter *= 2
|
|
|
|
|
|
|
|
else:
|
|
|
|
|
|
|
|
self.current_counter += 1
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def check_alarm(self, data):
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
Проверка триггера системы по dBFS во времени.
|
|
|
|
|
|
|
|
Один порог на канал, набор тревоги и сброс счетчиков как в main.
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
if self.check_init():
|
|
|
|
|
|
|
|
self.last_alarm_channels = []
|
|
|
|
|
|
|
|
for i in range(len(data)):
|
|
|
|
|
|
|
|
current = data[i]
|
|
|
|
|
|
|
|
threshold = self.get_threshold(i)
|
|
|
|
|
|
|
|
exceeding = current >= threshold
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if exceeding:
|
|
|
|
|
|
|
|
self.buffer_alarms[i] += 1
|
|
|
|
|
|
|
|
else:
|
|
|
|
|
|
|
|
self.buffer_alarms[i] = 0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if self.buffer_alarms[i] >= self.num_for_alarm:
|
|
|
|
|
|
|
|
self.last_alarm_channels = [i]
|
|
|
|
|
|
|
|
self.buffer_alarms = [0] * self.line_size
|
|
|
|
|
|
|
|
return True
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return False
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def check_single_alarm(self, median, cur_channel):
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
Проверка, является ли текущая метрика по каналу превышающей порог.
|
|
|
|
|
|
|
|
:param median: текущая метрика в dBFS.
|
|
|
|
|
|
|
|
:param cur_channel: индекс канала внутри частоты.
|
|
|
|
|
|
|
|
:return: Да/нет.
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
if self.check_init():
|
|
|
|
|
|
|
|
threshold = self.get_threshold(cur_channel)
|
|
|
|
|
|
|
|
return median >= threshold
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return False
|
|
|
|
|
Sergey Revyakin