def __init__(self, sensor_config, processing_config, session_info):
self.processing_config = processing_config
self.processing_config.bg.buffered_data = None
self.processing_config.bg.error = None
self.depths = utils.get_range_depths(sensor_config, session_info)
num_depths = self.depths.size
num_sensors = len(sensor_config.sensor)
buffer_length = self.processing_config.bg_buffer_length
self.bg_buffer = np.zeros([buffer_length, num_sensors, num_depths])
history_length = self.processing_config.history_length
self.history = np.zeros([history_length, num_sensors, num_depths])
self.data_index = 0
def __init__(self, sensor_config, processing_config, session_info):
num_sensors = len(sensor_config.sensor)
num_depths = utils.get_range_depths(sensor_config, session_info).size
history_len = processing_config.history_length
pd_config = presence_detection_sparse.get_processing_config()
processor_class = presence_detection_sparse.Processor
try:
self.pd_processors = [
processor_class(sensor_config, pd_config, session_info)
]
except AssertionError:
self.pd_processors = None
self.data_history = np.ones([history_len, num_sensors, num_depths
]) * 2**15
self.presence_history = np.zeros(
[history_len, num_sensors, num_depths])
def __init__(self, sensor_config, processing_config, session_info):
self.processing_config = processing_config
self.downsampling_factor = sensor_config.downsampling_factor
self.sweeps_per_frame = sensor_config.sweeps_per_frame
sweep_rate = session_info["sweep_rate"]
self.depths = utils.get_range_depths(sensor_config, session_info)
self.step_length = session_info["step_length_m"]
self.f_res = sweep_rate / self.sweeps_per_frame
self.fft_x_scale = 100 * self.step_length
self.smooth_max = utils.SmoothMax(
sweep_rate / self.sweeps_per_frame,
tau_grow=0,
tau_decay=0.5,
hysteresis=0.1,
)
self.setup_is_done = False
def __init__(self, sensor_config, processing_config, session_info):
self.f = sensor_config.update_rate
depths = utils.get_range_depths(sensor_config, session_info)
self.num_depths = depths.size
max_window_size = 2 ** ProcessingConfiguration.WINDOW_SIZE_POW_OF_2_MAX
self.sweep_history = np.full([max_window_size, self.num_depths], np.nan)
self.collapsed_asd = None
self.collapsed_asd_history = None
self.window_size = None
self.frames_between_updates = None
self.rolling_history_size = None
self.tick_idx = 0
self.last_update_tick = 0
self.update_processing_config(processing_config)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("filename")
args = parser.parse_args()
filename = args.filename
record = recording.load(filename)
print_record(record)
if len(record.data.shape) == 3: # Envelope, IQ, Power bins
x = np.arange(len(record.data))
y = utils.get_range_depths(record.sensor_config, record.session_info)
z = np.abs(record.data[:, 0, :]).T
fig, ax = plt.subplots()
ax.pcolormesh(x, y, z)
ax.set_xlabel("Sweep index")
ax.set_ylabel("Depth (m)")
fig.tight_layout()
plt.show()
def __init__(self, sensor_config, processing_config, session_info):
self.sensor_config = sensor_config
self.depths = utils.get_range_depths(sensor_config, session_info)
def main():
args = utils.ExampleArgumentParser(num_sens=1).parse_args()
utils.config_logging(args)
if args.socket_addr:
client = SocketClient(args.socket_addr)
elif args.spi:
client = SPIClient()
else:
port = args.serial_port or utils.autodetect_serial_port()
client = UARTClient(port)
config = configs.IQServiceConfig()
config.sensor = args.sensors
config.update_rate = 10
session_info = client.setup_session(config)
depths = utils.get_range_depths(config, session_info)
amplitude_y_max = 1000
fig, (amplitude_ax, phase_ax) = plt.subplots(2)
fig.set_size_inches(8, 6)
fig.canvas.set_window_title("Acconeer matplotlib example")
for ax in [amplitude_ax, phase_ax]:
ax.set_xlabel("Depth (m)")
ax.set_xlim(config.range_interval)
ax.grid(True)
amplitude_ax.set_ylabel("Amplitude")
amplitude_ax.set_ylim(0, 1.1 * amplitude_y_max)
phase_ax.set_ylabel("Phase")
utils.mpl_setup_yaxis_for_phase(phase_ax)
amplitude_line = amplitude_ax.plot(depths, np.zeros_like(depths))[0]
phase_line = phase_ax.plot(depths, np.zeros_like(depths))[0]
fig.tight_layout()
plt.ion()
plt.show()
interrupt_handler = utils.ExampleInterruptHandler()
print("Press Ctrl-C to end session")
client.start_session()
while not interrupt_handler.got_signal:
info, data = client.get_next()
amplitude = np.abs(data)
phase = np.angle(data)
max_amplitude = np.max(amplitude)
if max_amplitude > amplitude_y_max:
amplitude_y_max = max_amplitude
amplitude_ax.set_ylim(0, 1.1 * max_amplitude)
amplitude_line.set_ydata(amplitude)
phase_line.set_ydata(phase)
if not plt.fignum_exists(1): # Simple way to check if plot is closed
break
fig.canvas.flush_events()
print("Disconnecting...")
plt.close()
client.disconnect()
def process(self, sweep):
mode = self.sensor_config.mode
if self.sweep == 0:
self.x_mm = utils.get_range_depths(self.sensor_config, self.session_info) * 1000
if mode == Mode.SPARSE:
self.num_sensors, point_repeats, self.data_len = sweep.shape
self.hist_env = np.zeros((self.num_sensors, self.data_len, self.image_buffer))
else:
self.data_len = sweep.size
self.num_sensors = 1
if len(sweep.shape) > 1:
self.num_sensors, self.data_len = sweep.shape
self.hist_env = np.zeros(
(self.num_sensors, self.data_len, self.image_buffer)
)
sweep_data = sweep.copy()
env = None
if mode == Mode.SPARSE:
env = sweep.mean(axis=1)
else:
env = np.abs(sweep_data)
for s in range(self.num_sensors):
self.hist_env[s, :, :] = np.roll(self.hist_env[s, :, :], 1, axis=1)
self.hist_env[s, :, 0] = env[s, :]
plot_data = {
"sweep_data": sweep_data,
"env_ampl": env,
"hist_env": self.hist_env,
"sensor_config": self.sensor_config,
"x_mm": self.x_mm,
"sweep": self.sweep,
"num_sensors": self.num_sensors,
"ml_plotting": True,
"ml_frame_data": None,
"prediction": None,
"prediction_hist": None,
"session_info": self.session_info,
}
plot_data["ml_frame_data"] = self.feature_process.feature_extraction(plot_data)
feature_map = plot_data["ml_frame_data"]["current_frame"]["feature_map"]
complete = plot_data["ml_frame_data"]["current_frame"]["frame_complete"]
if complete and self.evaluate and feature_map is not None:
if plot_data["ml_frame_data"]["frame_info"].get("time_series", 1) > 1:
feature_map = ml_helper.convert_time_series(
plot_data["ml_frame_data"]["current_frame"]["feature_map"],
plot_data["ml_frame_data"]["frame_info"]
)
try:
plot_data["prediction"] = self.evaluate(feature_map)
except Exception as e:
print(e)
plot_data["ml_frame_data"]["current_frame"]["frame_complete"] = False
return plot_data
prediction_label = plot_data["prediction"]["prediction"]
plot_data["ml_frame_data"]["frame_list"][-1]["label"] = prediction_label
if self.prediction_hist is None:
self.prediction_hist = np.zeros((plot_data["prediction"]["number_labels"],
self.hist_len))
predictions = plot_data["prediction"]["label_predictions"]
self.prediction_hist = np.roll(self.prediction_hist, 1, axis=1)
for key in predictions:
pred, idx = predictions[key]
self.prediction_hist[idx, 0] = pred
plot_data["prediction_hist"] = self.prediction_hist
self.sweep += 1
return plot_data
def __init__(self, sensor_config, processing_config, session_info):
self.depths = utils.get_range_depths(sensor_config, session_info)
self.smooth_max = utils.SmoothMax(sensor_config.update_rate)
