"""

Given a sound pressure waveform, vocal_band, find areas with vocalizations (extended power).

Strongly recommended to bandpass the wave first (for instance, just pass 2-5 kHz).

Performs two thresholding steps (Honestly I'm not sure how helpful the second one is but that's what I'm doing for now),

each one is done based on standard deviations above mean, with the vocal density being windows (~low pass filtered)

Returns:

sound_onset, sound_offset- two vectors of the same length (hopefully!)

Arguments:

REQUIRED:

vocal_band: sound pressssure waveform, ideally band-pass filtered

OPTIONAL

vb_stds: vocal band standard deviations- power is determined by thresholding above this

vd_stds: vocal density standard deviations- power is determined by thresholding above this

vd_win: for smoothing the vocal density vector (second thresholding step)

fs_mic: 25000 is our standard

onset_shift: Many vocalizations start quietly so it's often best to just move all onsets a little back in time

TODO Not sure why I chose to window/bin the second thresholding step instead of low-passing it, should think about that more

"""

vocal_band_thresh = vb_stds * np.std(vocal_band)

# find periods of time above the threshold...

vocal_threshed = np.zeros(vocal_band.shape)

for i in range(vocal_band.shape[0]):

if vocal_band[i] > vocal_band_thresh:

vocal_threshed[i] = 1

else: vocal_threshed[i] = 0

# TODO it's pretty weird the way I'm windowing this, maybe I should just lowpass filter it?

window = np.int(np.round(vd_win * fs_mic / 2) * 2) # force an even integer

overlap = window / 2

start_time = 0

i = 0

vocal_density = np.zeros(np.int(np.floor(vocal_band.shape[0]/(window-overlap))))

while start_time + window < vocal_band.shape[0]:

vocal_density[i] = np.mean(vocal_threshed[start_time:start_time+window])

start_time = start_time + window - overlap

i += 1

# sound onsets: 1 is an onset, -1 is an offset

density_thresh = vd_stds * np.std(vocal_density)

vd_crosses = np.zeros(len(vocal_density))

for i in range(vocal_density.shape[0]):

if vocal_density[i] > density_thresh:

vd_crosses[i] = 1

sound_onsets = vd_crosses[1:len(vd_crosses)] - vd_crosses[0:len(vd_crosses)-1]

sound_onsetsb = np.zeros(len(sound_onsets)+1)

sound_onsetsb[1:len(sound_onsetsb)] = sound_onsets # just aligns for n-1, must be a better way oh well

del sound_onsets

sound_onsets = sound_onsetsb

del sound_onsetsb

# this just checks that the first sound onset wasn't obscured by the beginning of the file

for i in range(len(sound_onsets)):

if sound_onsets[i] == -1:

sound_onsets[0] = -1 # the case where sound onset happens on the first data point

print("Warning, sound appears to onset before file start, first time point being set to an onset")

if sound_onsets[i] == 1:

break

# check for missing offset (sound continues past data file)

for i in range(len(sound_onsets)):

if sound_onsets[len(sound_onsets)-i-1] == 1:

sound_onsets[len(sound_onsets)] = -1

print("Warning, sound appears to continue past file end, last time point being set to an offset")

if sound_onsets[len(sound_onsets)-i-1] == -1:

break

# convert to a list of just onsets and offsets

sound_onset = []

sound_offset = []

for i in range(len(sound_onsets)):

if sound_onsets[i] == 1:

sound_onset = np.append(sound_onset, [i])

if sound_onsets[i] == -1:

sound_offset = np.append(sound_offset, [i])

try:

len(sound_onset) == len(sound_offset)

except:

print("Number of vocal onsets and offsets not equal!")

sound_onset = sound_onset * (window - overlap) # convert to original data points

sound_onset = sound_onset + np.round(onset_shift * fs_mic)

sound_offset = sound_offset * (window - overlap) # " "

"""

Calculate cross correlation between two spectrograms over only some frequencies, across time. Expects one wav file and

one spectrogram and a frequency index. The spectrogram 'timefreq' should already be zscored.

Returns:

correlation: spect_corr

Arguments:

REQUIRED:

sound_wav, templ_timefreq, freq_index

"""

t, freq, timefreq, rms = spectrogram(sound_wav, fs_mic, spec_sample_rate, freq_spacing)

timefreq = timefreq[freq_index,:]

timefreq = zscore(timefreq, axis = None)

# zero pad only if the vocalization is shorter than the template

if timefreq.shape[1] < templ_timefreq.shape[1]:

zeropad = np.zeros((timefreq.shape[0],templ_timefreq.shape[1]-timefreq.shape[1]))

timefreq = np.append(timefreq, zeropad, axis = 1)

spect_corr = np.zeros(timefreq.shape[1])# - templ_timefreq.shape[1])

spect_auto1 = np.zeros(timefreq.shape[1])

spect_auto2 = np.zeros(timefreq.shape[1])

freq_corr = np.zeros(len(freq_index))

freq_in1 = np.zeros(len(freq_index))

freq_in2 = np.zeros(len(freq_index))

# sliding time, taking the whole template with the vocalization sliding

for time_win in range(timefreq.shape[1] - templ_timefreq.shape[1]): # no overlap before or after

# correlate relative freq band to each other

for freq_i in range(len(freq_index)):

in1 = np.abs(templ_timefreq[freq_i])

in2 = np.abs(timefreq[freq_i][time_win:time_win + len(in1)])

# freq_corr[freq_i] = correlate(in1,in2, mode = 'valid')

freq_corr[freq_i] = np.sum(in1*in2)

freq_in1[freq_i] = np.sum(in1*in1)

freq_in2[freq_i] = np.sum(in2*in2)

spect_corr[time_win] = np.sum(freq_corr)

spect_auto1[time_win] = np.sum(freq_in1)

spect_auto2[time_win] = np.sum(freq_in2)

"""

Returns a spectrogram and a template, if i = 17 it's some sort of song

Really just a placeholder for a better template algorithm

TODO replace this with real code, like user defined sections of spectrograms

"""

template = mic[sound_onset[i]:sound_offset[i]]

template = template[4800:18000] #shift it, particular to this template

templ_t, templ_freq, templ_timefreq, templ_rms = spectrogram(template, fs_mic, spec_sample_rate = 1000, freq_spacing = 50)

figure()

plot_spectrogram(templ_t, templ_freq, templ_timefreq, dBNoise=80, colorbar = False)

# I stuck this all in 'sound_playback' so I could sort it by time

# good god this is ugly but i'm moving on for now

"""

Returns sound_playback, which = -1 if the sound is not accounted for by

a playback. Only checks for overlap in time, many playbacks may have vocalizations

in them that would be discarded and just considered playbacks with this method.

This is still pretty rough but works for now.

"""

stim_time = np.zeros(len(segment.epocharrays))

stim_duration = np.zeros(len(segment.epocharrays))

stimuli_times = list() #used temporarily

stim_id = list()

stim_name = list()

i = 0

for epoch in segment.epocharrays:

stimuli_times.append(epoch.times)

stim_id.append(sm.database.get_annotations(epoch.annotations["stim_id"]))

stim_name.append(stim_id[i]['callid'])

i = i + 1

for i in range(len(segment.epocharrays)):

stim_time[i] = segment.epocharrays[i].times #* 1000 # in s

stim_duration[i] = segment.epocharrays[i].durations # in s

sound_playback = np.zeros(len(sound_onset)) - 1

for i in range(len(sound_onset)):

for j in range(len(stim_time)):

time_diff = (((sound_onset[i] + sound_offset[i])/ 2) / fs_mic) - (stim_time[j] + (stim_duration[j] / 2))

if np.abs(time_diff) < ((((sound_offset[i]-sound_onset[i]) / 2) / fs_mic) + (stim_duration[j] / 2)): # vocalization overlaps with a stimuli

sound_playback[i] = j

[ 2019375., 2024625.],

[ 12380625., 12383125.],

[ 16674375., 16676875.],

[ 18352500., 18355000.],

[ 19248000., 19250500.],