raab/GP2023_chirp_detection
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' into alex

Browse Source
This commit is contained in:
Awendt 2023-01-13 16:04:13 +01:00
commit 41b75f1a68
2 changed files with 218 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

429
code/chirpdetection.py
View File

@ -187,22 +187,9 @@ def main(datapath: str) -> None:
# start_index = t0 * data.samplerate # start_index = t0 * data.samplerate
# stop_index = (t0 + dt) * data.samplerate # stop_index = (t0 + dt) * data.samplerate
fig, axs = plt.subplots(
7,
2,
figsize=(20 / 2.54, 12 / 2.54),
constrained_layout=True,
sharex=True,
sharey='row',
)
# iterate through all fish # iterate through all fish
for i, track_id in enumerate(np.unique(ident[~np.isnan(ident)])[:2]): for i, track_id in enumerate(np.unique(ident[~np.isnan(ident)])[:2]):
# load region of interest of raw data file
data_oi = data[start_index:stop_index, :]
time_oi = raw_time[start_index:stop_index]
# get indices for time array in time window # get indices for time array in time window
window_index = np.arange(len(idx))[ window_index = np.arange(len(idx))[
(ident == track_id) & (time[idx] >= t0) & ( (ident == track_id) & (time[idx] >= t0) & (
@ -220,213 +207,229 @@ def main(datapath: str) -> None:
if len(freq_temp) < expected_duration * 0.9: if len(freq_temp) < expected_duration * 0.9:
continue continue
fig, axs = plt.subplots(
7,
config.electrodes,
figsize=(20 / 2.54, 12 / 2.54),
constrained_layout=True,
sharex=True,
sharey='row',
)
# get best electrode # get best electrode
electrode = np.argsort(np.nanmean(powers_temp, axis=0))[-1] best_electrodes = np.argsort(np.nanmean(
powers_temp, axis=0))[-config.electrodes:]
# <------------------------------------------ Iterate through electrodes # <------------------------------------------ Iterate through electrodes
# plot wavetracker tracks to spectrogram for i, electrode in enumerate(best_electrodes):
# for track_id in np.unique(ident): # <---------- Find freq gaps later
# here # load region of interest of raw data file
data_oi = data[start_index:stop_index, :]
# # get indices for time array in time window time_oi = raw_time[start_index:stop_index]
# window_index = np.arange(len(idx))[
# (ident == track_id) & # plot wavetracker tracks to spectrogram
# (time[idx] >= t0) & # for track_id in np.unique(ident): # <---------- Find freq gaps later
# (time[idx] <= (t0 + dt)) # here
# ]
# # get indices for time array in time window
# freq_temp = freq[window_index] # window_index = np.arange(len(idx))[
# time_temp = time[idx[window_index]] # (ident == track_id) &
# (time[idx] >= t0) &
# axs[0].plot(time_temp-t0, freq_temp, lw=2) # (time[idx] <= (t0 + dt))
# axs[0].set_ylim(500, 1000) # ]
# track_id = ids # freq_temp = freq[window_index]
# time_temp = time[idx[window_index]]
# frequency where second filter filters
search_freq = 50 # axs[0].plot(time_temp-t0, freq_temp, lw=2)
# axs[0].set_ylim(500, 1000)
# filter baseline and above
baseline, search = double_bandpass( # track_id = ids
data_oi[:, electrode], data.samplerate, freq_temp, search_freq
) # frequency where second filter filters
search_freq = 50
# compute instantaneous frequency on broad signal
broad_baseline = bandpass_filter( # filter baseline and above
data_oi[:, electrode], baseline, search = double_bandpass(
data.samplerate, data_oi[:, electrode], data.samplerate, freq_temp, search_freq
lowf=np.mean(freq_temp)-5, )
highf=np.mean(freq_temp)+100
) # compute instantaneous frequency on broad signal
broad_baseline = bandpass_filter(
# compute instantaneous frequency on narrow signal data_oi[:, electrode],
baseline_freq_time, baseline_freq = instantaneos_frequency( data.samplerate,
baseline, data.samplerate lowf=np.mean(freq_temp)-5,
) highf=np.mean(freq_temp)+100
)
# compute envelopes
baseline_envelope = envelope( # compute instantaneous frequency on narrow signal
baseline, data.samplerate, config.envelope_cutoff) baseline_freq_time, baseline_freq = instantaneos_frequency(
search_envelope = envelope( baseline, data.samplerate
search, data.samplerate, config.envelope_cutoff) )
# highpass filter envelopes # compute envelopes
baseline_envelope = highpass_filter( baseline_envelope = envelope(
baseline_envelope, baseline, data.samplerate, config.envelope_cutoff)
data.samplerate, search_envelope = envelope(
config.envelope_highpass_cutoff search, data.samplerate, config.envelope_cutoff)
)
# highpass filter envelopes
baseline_envelope = np.abs(baseline_envelope) baseline_envelope = highpass_filter(
# search_envelope = highpass_filter( baseline_envelope,
# search_envelope, data.samplerate,
# data.samplerate, config.envelope_highpass_cutoff
# config.envelope_highpass_cutoff )
# )
baseline_envelope = np.abs(baseline_envelope)
# envelopes of filtered envelope of filtered baseline # search_envelope = highpass_filter(
baseline_envelope = envelope( # search_envelope,
np.abs(baseline_envelope), # data.samplerate,
data.samplerate, # config.envelope_highpass_cutoff
config.envelope_envelope_cutoff # )
)
# envelopes of filtered envelope of filtered baseline
baseline_envelope = envelope(
np.abs(baseline_envelope),
data.samplerate,
config.envelope_envelope_cutoff
)
# search_envelope = bandpass_filter( # search_envelope = bandpass_filter(
# search_envelope, data.samplerate, lowf=lowf, highf=highf) # search_envelope, data.samplerate, lowf=lowf, highf=highf)
# bandpass filter the instantaneous # bandpass filter the instantaneous
inst_freq_filtered = bandpass_filter( inst_freq_filtered = bandpass_filter(
baseline_freq, baseline_freq,
data.samplerate, data.samplerate,
lowf=config.instantaneous_lowf, lowf=config.instantaneous_lowf,
highf=config.instantaneous_highf highf=config.instantaneous_highf
) )
# test taking the log of the envelopes # test taking the log of the envelopes
# baseline_envelope = np.log(baseline_envelope) # baseline_envelope = np.log(baseline_envelope)
# search_envelope = np.log(search_envelope) # search_envelope = np.log(search_envelope)
# CUT OFF OVERLAP ------------------------------------------------- # CUT OFF OVERLAP -------------------------------------------------
# cut off first and last 0.5 * overlap at start and end # cut off first and last 0.5 * overlap at start and end
valid = np.arange( valid = np.arange(
int(window_overlap / 2), len(baseline_envelope) - int(window_overlap / 2), len(baseline_envelope) -
int(window_overlap / 2) int(window_overlap / 2)
) )
baseline_envelope = baseline_envelope[valid] baseline_envelope = baseline_envelope[valid]
search_envelope = search_envelope[valid] search_envelope = search_envelope[valid]
# get inst freq valid snippet # get inst freq valid snippet
valid_t0 = int(window_overlap / 2) / data.samplerate valid_t0 = int(window_overlap / 2) / data.samplerate
valid_t1 = baseline_freq_time[-1] - \ valid_t1 = baseline_freq_time[-1] - \
(int(window_overlap / 2) / data.samplerate) (int(window_overlap / 2) / data.samplerate)
inst_freq_filtered = inst_freq_filtered[(baseline_freq_time >= valid_t0) & ( inst_freq_filtered = inst_freq_filtered[(baseline_freq_time >= valid_t0) & (
baseline_freq_time <= valid_t1)] baseline_freq_time <= valid_t1)]
baseline_freq = baseline_freq[(baseline_freq_time >= valid_t0) & ( baseline_freq = baseline_freq[(baseline_freq_time >= valid_t0) & (
baseline_freq_time <= valid_t1)] baseline_freq_time <= valid_t1)]
baseline_freq_time = baseline_freq_time[(baseline_freq_time >= valid_t0) & ( baseline_freq_time = baseline_freq_time[(baseline_freq_time >= valid_t0) & (
baseline_freq_time <= valid_t1)] + t0 baseline_freq_time <= valid_t1)] + t0
# overwrite raw time to valid region # overwrite raw time to valid region
time_oi = time_oi[valid] time_oi = time_oi[valid]
baseline = baseline[valid] baseline = baseline[valid]
broad_baseline = broad_baseline[valid] broad_baseline = broad_baseline[valid]
search = search[valid] search = search[valid]
# PEAK DETECTION -------------------------------------------------- # PEAK DETECTION --------------------------------------------------
# detect peaks baseline_enelope # detect peaks baseline_enelope
prominence = np.percentile( prominence = np.percentile(
baseline_envelope, config.baseline_prominence_percentile) baseline_envelope, config.baseline_prominence_percentile)
baseline_peaks, _ = find_peaks( baseline_peaks, _ = find_peaks(
np.abs(baseline_envelope), prominence=prominence) np.abs(baseline_envelope), prominence=prominence)
# detect peaks search_envelope # detect peaks search_envelope
prominence = np.percentile( prominence = np.percentile(
search_envelope, config.search_prominence_percentile) search_envelope, config.search_prominence_percentile)
search_peaks, _ = find_peaks( search_peaks, _ = find_peaks(
search_envelope, prominence=prominence) search_envelope, prominence=prominence)
# detect peaks inst_freq_filtered # detect peaks inst_freq_filtered
prominence = np.percentile( prominence = np.percentile(
inst_freq_filtered, config.instantaneous_prominence_percentile) inst_freq_filtered, config.instantaneous_prominence_percentile)
inst_freq_peaks, _ = find_peaks( inst_freq_peaks, _ = find_peaks(
np.abs(inst_freq_filtered), prominence=prominence) np.abs(inst_freq_filtered), prominence=prominence)
# PLOT ------------------------------------------------------------ # PLOT ------------------------------------------------------------
# plot spectrogram # plot spectrogram
plot_spectrogram( plot_spectrogram(
axs[0, i], data_oi[:, electrode], data.samplerate, t0) axs[0, i], data_oi[:, electrode], data.samplerate, t0)
# plot baseline instantaneos frequency # plot baseline instantaneos frequency
axs[1, i].plot(baseline_freq_time, baseline_freq - axs[1, i].plot(baseline_freq_time, baseline_freq -
np.median(baseline_freq), marker=".") np.median(baseline_freq), marker=".")
# plot waveform of filtered signal # plot waveform of filtered signal
axs[2, i].plot(time_oi, baseline, c="k") axs[2, i].plot(time_oi, baseline, c="k")
# plot narrow filtered baseline # plot narrow filtered baseline
axs[2, i].plot( axs[2, i].plot(
time_oi, time_oi,
baseline_envelope, baseline_envelope,
c="orange", c="orange",
) )
# plot broad filtered baseline # plot broad filtered baseline
axs[2, i].plot( axs[2, i].plot(
time_oi, time_oi,
broad_baseline, broad_baseline,
c="green", c="green",
) )
# plot waveform of filtered search signal # plot waveform of filtered search signal
axs[3, i].plot(time_oi, search) axs[3, i].plot(time_oi, search)
# plot envelope of search signal # plot envelope of search signal
axs[3, i].plot( axs[3, i].plot(
time_oi, time_oi,
search_envelope, search_envelope,
c="orange", c="orange",
) )
# plot filtered and rectified envelope # plot filtered and rectified envelope
axs[4, i].plot(time_oi, baseline_envelope) axs[4, i].plot(time_oi, baseline_envelope)
axs[4, i].scatter( axs[4, i].scatter(
(time_oi)[baseline_peaks], (time_oi)[baseline_peaks],
baseline_envelope[baseline_peaks], baseline_envelope[baseline_peaks],
c="red", c="red",
) )
# plot envelope of search signal # plot envelope of search signal
axs[5, i].plot(time_oi, search_envelope) axs[5, i].plot(time_oi, search_envelope)
axs[5, i].scatter( axs[5, i].scatter(
(time_oi)[search_peaks], (time_oi)[search_peaks],
search_envelope[search_peaks], search_envelope[search_peaks],
c="red", c="red",
) )
# plot filtered instantaneous frequency # plot filtered instantaneous frequency
axs[6, i].plot(baseline_freq_time, np.abs(inst_freq_filtered)) axs[6, i].plot(baseline_freq_time, np.abs(inst_freq_filtered))
axs[6, i].scatter( axs[6, i].scatter(
baseline_freq_time[inst_freq_peaks], baseline_freq_time[inst_freq_peaks],
np.abs(inst_freq_filtered)[inst_freq_peaks], np.abs(inst_freq_filtered)[inst_freq_peaks],
c="red", c="red",
) )
axs[6, i].set_xlabel("Time [s]") axs[6, i].set_xlabel("Time [s]")
axs[0, i].set_title("Spectrogram") axs[0, i].set_title("Spectrogram")
axs[1, i].set_title("Fitered baseline instanenous frequency") axs[1, i].set_title("Fitered baseline instanenous frequency")
axs[2, i].set_title("Fitered baseline") axs[2, i].set_title("Fitered baseline")
axs[3, i].set_title("Fitered above") axs[3, i].set_title("Fitered above")
axs[4, i].set_title("Filtered envelope of baseline envelope") axs[4, i].set_title("Filtered envelope of baseline envelope")
axs[5, i].set_title("Search envelope") axs[5, i].set_title("Search envelope")
axs[6, i].set_title("Filtered absolute instantaneous frequency") axs[6, i].set_title(
"Filtered absolute instantaneous frequency")
plt.show()
plt.show()
if __name__ == "__main__": if __name__ == "__main__":

3
code/chirpdetector_conf.yml
View File

@ -1,6 +1,7 @@
# Duration and overlap of the analysis window in seconds # Duration and overlap of the analysis window in seconds
window: 5 window: 5
overlap: 0.5 overlap: 1
edges: 0.25
# Number of electrodes to go over # Number of electrodes to go over
electrodes: 3 electrodes: 3