diff --git a/code/plot_introduction_specs.py b/code/plot_introduction_specs.py index 20fb562..51cee38 100644 --- a/code/plot_introduction_specs.py +++ b/code/plot_introduction_specs.py @@ -17,7 +17,7 @@ def main(): data = LoadData(datapath) # good chirp times for data: 2022-06-02-10_00 - window_start_seconds = 3 * 60 * 60 + 6 * 60 + 43.5 + 9 + 6.25 + window_start_seconds = 3 * 60 * 60 + 6 * 60 + 43.5 + 9 + 6.24 window_start_index = window_start_seconds * data.raw_rate window_duration_seconds = 0.2 window_duration_index = window_duration_seconds * data.raw_rate @@ -27,8 +27,8 @@ def main(): raw = data.raw[window_start_index:window_start_index + window_duration_index, 10] - fig, (ax1, ax2, ax3) = plt.subplots( - 3, 1, figsize=(12 * ps.cm, 10*ps.cm), sharex=True, sharey=True) + fig, ax = plt.subplots( + 1, 1, figsize=(14 * ps.cm, 6*ps.cm), sharex=True, sharey=True) # plot instantaneous frequency filtered1 = bandpass_filter( @@ -41,13 +41,14 @@ def main(): freqtime2, freq2 = instantaneous_frequency( filtered2, data.raw_rate, smoothing_window=3) - ax1.plot(freqtime1*timescaler, freq1, color=ps.red, - lw=2, label=f"fish 1, {np.median(freq1):.0f} Hz") - ax1.plot(freqtime2*timescaler, freq2, color=ps.orange, - lw=2, label=f"fish 2, {np.median(freq2):.0f} Hz") - ax1.legend(bbox_to_anchor=(0, 1.02, 1, 0.2), loc="lower center", - mode="normal", borderaxespad=0, ncol=2) - ps.hide_xax(ax1) + ax.plot(freqtime1*timescaler, freq1, color=ps.red, + lw=2, label="fish 1") + ax.plot(freqtime2*timescaler, freq2, color=ps.orange, + lw=2, label="fish 2") + ax.legend(bbox_to_anchor=(0, 1.02, 1, 0.2), loc="lower center", + mode="normal", borderaxespad=0, ncol=2) + # ax.legend(bbox_to_anchor=(1.04, 1), borderaxespad=0) + # # ps.hide_xax(ax1) # plot fine spectrogram spec_power, spec_freqs, spec_times = spectrogram( @@ -57,11 +58,11 @@ def main(): overlap_frac=0.2, ) - ylims = [300, 1200] + ylims = [300, 1300] fmask = np.zeros(spec_freqs.shape, dtype=bool) fmask[(spec_freqs > ylims[0]) & (spec_freqs < ylims[1])] = True - ax2.imshow( + ax.imshow( decibel(spec_power[fmask, :]), extent=[ spec_times[0]*timescaler, @@ -73,45 +74,47 @@ def main(): origin="lower", interpolation="gaussian", alpha=1, + vmin=-100, + vmax=-80, ) - ps.hide_xax(ax2) - - # plot coarse spectrogram - spec_power, spec_freqs, spec_times = spectrogram( - raw, - ratetime=data.raw_rate, - freq_resolution=10, - overlap_frac=0.3, - ) - fmask = np.zeros(spec_freqs.shape, dtype=bool) - fmask[(spec_freqs > ylims[0]) & (spec_freqs < ylims[1])] = True - ax3.imshow( - decibel(spec_power[fmask, :]), - extent=[ - spec_times[0]*timescaler, - spec_times[-1]*timescaler, - spec_freqs[fmask][0], - spec_freqs[fmask][-1], - ], - aspect="auto", - origin="lower", - interpolation="gaussian", - alpha=1, - ) - # ps.hide_xax(ax3) - - ax3.set_xlabel("time [ms]") - ax2.set_ylabel("frequency [Hz]") - - ax1.set_yticks(np.arange(400, 1201, 400)) - ax1.spines.left.set_bounds((400, 1200)) - ax2.set_yticks(np.arange(400, 1201, 400)) - ax2.spines.left.set_bounds((400, 1200)) - ax3.set_yticks(np.arange(400, 1201, 400)) - ax3.spines.left.set_bounds((400, 1200)) - - plt.subplots_adjust(left=0.17, right=0.98, top=0.9, - bottom=0.14, hspace=0.35) + # ps.hide_xax(ax2) + + # # plot coarse spectrogram + # spec_power, spec_freqs, spec_times = spectrogram( + # raw, + # ratetime=data.raw_rate, + # freq_resolution=10, + # overlap_frac=0.3, + # ) + # fmask = np.zeros(spec_freqs.shape, dtype=bool) + # fmask[(spec_freqs > ylims[0]) & (spec_freqs < ylims[1])] = True + # ax3.imshow( + # decibel(spec_power[fmask, :]), + # extent=[ + # spec_times[0]*timescaler, + # spec_times[-1]*timescaler, + # spec_freqs[fmask][0], + # spec_freqs[fmask][-1], + # ], + # aspect="auto", + # origin="lower", + # interpolation="gaussian", + # alpha=1, + # ) + # # ps.hide_xax(ax3) + + ax.set_xlabel("time [ms]") + ax.set_ylabel("frequency [Hz]") + + # ax.set_yticks(np.arange(400, 1201, 400)) + # ax.spines.left.set_bounds((400, 1200)) + # ax2.set_yticks(np.arange(400, 1201, 400)) + # ax2.spines.left.set_bounds((400, 1200)) + # ax3.set_yticks(np.arange(400, 1201, 400)) + # ax3.spines.left.set_bounds((400, 1200)) + + plt.subplots_adjust(left=0.17, right=0.98, top=0.87, + bottom=0.24, hspace=0.35) plt.savefig('../poster/figs/introplot.pdf') plt.show() diff --git a/code/plot_kdes.py b/code/plot_kdes.py index 5fd9cad..bf4accd 100644 --- a/code/plot_kdes.py +++ b/code/plot_kdes.py @@ -1,18 +1,18 @@ -from extract_chirps import get_valid_datasets -import os - -import numpy as np -import pandas as pd -import matplotlib.pyplot as plt -from tqdm import tqdm -from IPython import embed -from pandas import read_csv -from modules.logger import makeLogger -from modules.datahandling import flatten, causal_kde1d, acausal_kde1d +from modules.plotstyle import PlotStyle from modules.behaviour_handling import ( Behavior, correct_chasing_events, center_chirps) -from modules.plotstyle import PlotStyle +from modules.datahandling import flatten, causal_kde1d, acausal_kde1d +from modules.logger import makeLogger +from pandas import read_csv +from IPython import embed +from tqdm import tqdm +import matplotlib.pyplot as plt +import pandas as pd +import numpy as np +import os +from extract_chirps import get_valid_datasets + logger = makeLogger(__name__) ps = PlotStyle() @@ -23,16 +23,16 @@ def bootstrap(data, nresamples, kde_time, kernel_width, event_times, time_before bootstrapped_kdes = [] data = data[data <= 3*60*60] # only night time - # diff_data = np.diff(np.sort(data), prepend=0) + diff_data = np.diff(np.sort(data), prepend=0) # if len(data) != 0: # mean_chirprate = (len(data) - 1) / (data[-1] - data[0]) for i in tqdm(range(nresamples)): - # np.random.shuffle(diff_data) + np.random.shuffle(diff_data) - # bootstrapped_data = np.cumsum(diff_data) - bootstrapped_data = data + np.random.randn(len(data)) * 10 + bootstrapped_data = np.cumsum(diff_data) + # bootstrapped_data = data + np.random.randn(len(data)) * 10 bootstrap_data_centered = center_chirps( bootstrapped_data, event_times, time_before, time_after) @@ -40,8 +40,8 @@ def bootstrap(data, nresamples, kde_time, kernel_width, event_times, time_before bootstrapped_kde = acausal_kde1d( bootstrap_data_centered, time=kde_time, width=kernel_width) - # bootstrapped_kdes = list(np.asarray( - # bootstrapped_kdes) / len(event_times)) + bootstrapped_kde = list(np.asarray( + bootstrapped_kde) / len(event_times)) bootstrapped_kdes.append(bootstrapped_kde) @@ -58,21 +58,21 @@ def jackknife(data, nresamples, subsetsize, kde_time, kernel_width, event_times, for i in tqdm(range(nresamples)): - bootstrapped_data = np.random.sample(data, subsetsize, replace=False) - - bootstrapped_data = np.cumsum(diff_data) + jackknifed_data = np.random.choice( + diff_data, subsetsize, replace=False) - bootstrap_data_centered = center_chirps( - bootstrapped_data, event_times, time_before, time_after) + jackknifed_data = np.cumsum(jackknifed_data) - bootstrapped_kde = acausal_kde1d( - bootstrap_data_centered, time=kde_time, width=kernel_width) + jackknifed_data_centered = center_chirps( + jackknifed_data, event_times, time_before, time_after) - # bootstrapped_kdes = list(np.asarray( - # bootstrapped_kdes) / len(event_times)) + jackknifed_kde = acausal_kde1d( + jackknifed_data_centered, time=kde_time, width=kernel_width) - jackknife_kdes.append(bootstrapped_kde) + jackknifed_kde = list(np.asarray( + jackknifed_kde) / len(event_times)) + jackknife_kdes.append(jackknifed_kde) return jackknife_kdes @@ -102,14 +102,14 @@ def get_chirp_winner_loser(folder_name, Behavior, order_meta_df): def main(dataroot): - foldernames, _ = get_valid_datasets(dataroot) + foldernames, _ = np.asarray(get_valid_datasets(dataroot)) plot_all = True - time_before = 60 - time_after = 60 + time_before = 90 + time_after = 90 dt = 0.001 - kernel_width = 1 + kernel_width = 2 kde_time = np.arange(-time_before, time_after, dt) - nbootstraps = 2 + nbootstraps = 50 meta_path = ( '/').join(foldernames[0].split('/')[:-2]) + '/order_meta.csv' @@ -135,9 +135,19 @@ def main(dataroot): onset_count = 0 offset_count = 0 physical_count = 0 - + # winner_count = 0 + # loser_count = 0 + # winner_onset_chirpcount = 0 + # winner_offset_chirpcount = 0 + # winner_physical_chirpcount = 0 + # loser_onset_chirpcount = 0 + # loser_offset_chirpcount = 0 + # loser_physical_chirpcount = 0 + fig, ax = plt.subplots(1, 2, figsize=( + 14 * ps.cm, 7*ps.cm), sharey=True, sharex=True) # Iterate over all recordings and save chirp- and event-timestamps - for folder in tqdm(foldernames): + good_recs = np.asarray([0, 15]) + for i, folder in tqdm(enumerate(foldernames[good_recs])): foldername = folder.split('/')[-2] # logger.info('Loading data from folder: {}'.format(foldername)) @@ -153,9 +163,10 @@ def main(dataroot): timestamps = timestamps[timestamps < 3*60*60] # only night time winner, loser = get_chirp_winner_loser(folder, bh, meta) - if winner is None: continue + # winner_count += len(winner) + # loser_count += len(loser) onsets = (timestamps[category == 0]) offsets = (timestamps[category == 1]) @@ -179,42 +190,48 @@ def main(dataroot): loser_physicals.append(center_chirps( loser, physicals, time_before, time_after)) + # winner_onset_chirpcount += len(winner_onsets[-1]) + # winner_offset_chirpcount += len(winner_offsets[-1]) + # winner_physical_chirpcount += len(winner_physicals[-1]) + # loser_onset_chirpcount += len(loser_onsets[-1]) + # loser_offset_chirpcount += len(loser_offsets[-1]) + # loser_physical_chirpcount += len(loser_physicals[-1]) # bootstrap # chirps = [winner, winner, winner, loser, loser, loser] - winner_onsets_boot.append(bootstrap( - winner, - nresamples=nbootstraps, - kde_time=kde_time, - kernel_width=kernel_width, - event_times=onsets, - time_before=time_before, - time_after=time_after)) - winner_offsets_boot.append(bootstrap( - winner, - nresamples=nbootstraps, - kde_time=kde_time, - kernel_width=kernel_width, - event_times=offsets, - time_before=time_before, - time_after=time_after)) - winner_physicals_boot.append(bootstrap( - winner, - nresamples=nbootstraps, - kde_time=kde_time, - kernel_width=kernel_width, - event_times=physicals, - time_before=time_before, - time_after=time_after)) - - loser_onsets_boot.append(bootstrap( - loser, - nresamples=nbootstraps, - kde_time=kde_time, - kernel_width=kernel_width, - event_times=onsets, - time_before=time_before, - time_after=time_after)) + # winner_onsets_boot.append(bootstrap( + # winner, + # nresamples=nbootstraps, + # kde_time=kde_time, + # kernel_width=kernel_width, + # event_times=onsets, + # time_before=time_before, + # time_after=time_after)) + # winner_offsets_boot.append(bootstrap( + # winner, + # nresamples=nbootstraps, + # kde_time=kde_time, + # kernel_width=kernel_width, + # event_times=offsets, + # time_before=time_before, + # time_after=time_after)) + # winner_physicals_boot.append(bootstrap( + # winner, + # nresamples=nbootstraps, + # kde_time=kde_time, + # kernel_width=kernel_width, + # event_times=physicals, + # time_before=time_before, + # time_after=time_after)) + + # loser_onsets_boot.append(bootstrap( + # loser, + # nresamples=nbootstraps, + # kde_time=kde_time, + # kernel_width=kernel_width, + # event_times=onsets, + # time_before=time_before, + # time_after=time_after)) loser_offsets_boot.append(bootstrap( loser, nresamples=nbootstraps, @@ -223,61 +240,99 @@ def main(dataroot): event_times=offsets, time_before=time_before, time_after=time_after)) - loser_physicals_boot.append(bootstrap( + # loser_physicals_boot.append(bootstrap( + # loser, + # nresamples=nbootstraps, + # kde_time=kde_time, + # kernel_width=kernel_width, + # event_times=physicals, + # time_before=time_before, + # time_after=time_after)) + + loser_offsets_jackknife = jackknife( loser, nresamples=nbootstraps, + subsetsize=0.5, kde_time=kde_time, kernel_width=kernel_width, - event_times=physicals, + event_times=offsets, time_before=time_before, - time_after=time_after)) + time_after=time_after) if plot_all: - winner_onsets_conv = acausal_kde1d( - winner_onsets[-1], kde_time, kernel_width) - winner_offsets_conv = acausal_kde1d( - winner_offsets[-1], kde_time, kernel_width) - winner_physicals_conv = acausal_kde1d( - winner_physicals[-1], kde_time, kernel_width) + # winner_onsets_conv = acausal_kde1d( + # winner_onsets[-1], kde_time, kernel_width) + # winner_offsets_conv = acausal_kde1d( + # winner_offsets[-1], kde_time, kernel_width) + # winner_physicals_conv = acausal_kde1d( + # winner_physicals[-1], kde_time, kernel_width) - loser_onsets_conv = acausal_kde1d( - loser_onsets[-1], kde_time, kernel_width) + # loser_onsets_conv = acausal_kde1d( + # loser_onsets[-1], kde_time, kernel_width) loser_offsets_conv = acausal_kde1d( loser_offsets[-1], kde_time, kernel_width) - loser_physicals_conv = acausal_kde1d( - loser_physicals[-1], kde_time, kernel_width) - - fig, ax = plt.subplots(2, 3, figsize=( - 21*ps.cm, 10*ps.cm), sharey=True, sharex=True) - ax[0, 0].set_title( - f"{foldername}, onsets {len(onsets)}, offsets {len(offsets)}, physicals {len(physicals)},winner {len(winner)}, looser {len(loser)} , onsets") - ax[0, 0].plot(kde_time, winner_onsets_conv/len(onsets)) - ax[0, 1].plot(kde_time, winner_offsets_conv/len(offsets)) - ax[0, 2].plot(kde_time, winner_physicals_conv/len(physicals)) - ax[1, 0].plot(kde_time, loser_onsets_conv/len(onsets)) - ax[1, 1].plot(kde_time, loser_offsets_conv/len(offsets)) - ax[1, 2].plot(kde_time, loser_physicals_conv/len(physicals)) + # loser_physicals_conv = acausal_kde1d( + # loser_physicals[-1], kde_time, kernel_width) + + ax[i].plot(kde_time, loser_offsets_conv/len(offsets)) + + ax[i].fill_between( + kde_time, + np.percentile(loser_offsets_boot[-1], 5, axis=0), + np.percentile(loser_offsets_boot[-1], 95, axis=0), + color=ps.gray, + alpha=0.5) + + ax[i].plot(kde_time, np.median(loser_offsets_boot[-1], axis=0), + color=ps.black, linewidth=2) + + ax[i].fill_between( + kde_time, + np.percentile(loser_offsets_jackknife, 5, axis=0), + np.percentile(loser_offsets_jackknife, 95, axis=0), + color=ps.blue, + alpha=0.5) + ax[i].plot(kde_time, np.median(loser_offsets_jackknife, axis=0), + color=ps.white, linewidth=2) + + ax[i].set_xlim(-60, 60) + + embed() + + # fig, ax = plt.subplots(2, 3, figsize=( + # 21*ps.cm, 10*ps.cm), sharey=True, sharex=True) + # ax[0, 0].set_title( + # f"{foldername}, onsets {len(onsets)}, offsets {len(offsets)}, physicals {len(physicals)},winner {len(winner)}, looser {len(loser)} , onsets") + # ax[0, 0].plot(kde_time, winner_onsets_conv/len(onsets)) + # ax[0, 1].plot(kde_time, winner_offsets_conv / + # len(offsets)) + # ax[0, 2].plot(kde_time, winner_physicals_conv / + # len(physicals)) + # ax[1, 0].plot(kde_time, loser_onsets_conv/len(onsets)) + # ax[1, 1].plot(kde_time, loser_offsets_conv/len(offsets)) + # ax[1, 2].plot(kde_time, loser_physicals_conv / + # len(physicals)) # # plot bootstrap lines - for kde in winner_onsets_boot[-1]: - ax[0, 0].plot(kde_time, kde/len(onsets), - color='gray') - for kde in winner_offsets_boot[-1]: - ax[0, 1].plot(kde_time, kde/len(offsets), - color='gray') - for kde in winner_physicals_boot[-1]: - ax[0, 2].plot(kde_time, kde/len(physicals), - color='gray') - for kde in loser_onsets_boot[-1]: - ax[1, 0].plot(kde_time, kde/len(onsets), - color='gray') - for kde in loser_offsets_boot[-1]: - ax[1, 1].plot(kde_time, kde/len(offsets), - color='gray') - for kde in loser_physicals_boot[-1]: - ax[1, 2].plot(kde_time, kde/len(physicals), - color='gray') + # for kde in winner_onsets_boot[-1]: + # ax[0, 0].plot(kde_time, kde, + # color='gray') + # for kde in winner_offsets_boot[-1]: + # ax[0, 1].plot(kde_time, kde, + # color='gray') + # for kde in winner_physicals_boot[-1]: + # ax[0, 2].plot(kde_time, kde, + # color='gray') + # for kde in loser_onsets_boot[-1]: + # ax[1, 0].plot(kde_time, kde, + # color='gray') + # for kde in loser_offsets_boot[-1]: + # ax[1, 1].plot(kde_time, kde, + # color='gray') + # for kde in loser_physicals_boot[-1]: + # ax[1, 2].plot(kde_time, kde, + # color='gray') # plot bootstrap percentiles # ax[0, 0].fill_between( @@ -335,79 +390,79 @@ def main(dataroot): # ax[1, 2].plot(kde_time, np.median(loser_physicals_boot[-1], axis=0), # color='black', linewidth=2) - ax[0, 0].set_xlim(-30, 30) - plt.show() - - winner_onsets = np.sort(flatten(winner_onsets)) - winner_offsets = np.sort(flatten(winner_offsets)) - winner_physicals = np.sort(flatten(winner_physicals)) - loser_onsets = np.sort(flatten(loser_onsets)) - loser_offsets = np.sort(flatten(loser_offsets)) - loser_physicals = np.sort(flatten(loser_physicals)) - - winner_onsets_conv = acausal_kde1d( - winner_onsets, kde_time, kernel_width) - winner_offsets_conv = acausal_kde1d( - winner_offsets, kde_time, kernel_width) - winner_physicals_conv = acausal_kde1d( - winner_physicals, kde_time, kernel_width) - loser_onsets_conv = acausal_kde1d( - loser_onsets, kde_time, kernel_width) - loser_offsets_conv = acausal_kde1d( - loser_offsets, kde_time, kernel_width) - loser_physicals_conv = acausal_kde1d( - loser_physicals, kde_time, kernel_width) - - winner_onsets_conv = winner_onsets_conv / onset_count - winner_offsets_conv = winner_offsets_conv / offset_count - winner_physicals_conv = winner_physicals_conv / physical_count - loser_onsets_conv = loser_onsets_conv / onset_count - loser_offsets_conv = loser_offsets_conv / offset_count - loser_physicals_conv = loser_physicals_conv / physical_count - - winner_onsets_boot = np.concatenate( - winner_onsets_boot) - winner_offsets_boot = np.concatenate( - winner_offsets_boot) - winner_physicals_boot = np.concatenate( - winner_physicals_boot) - loser_onsets_boot = np.concatenate( - loser_onsets_boot) - loser_offsets_boot = np.concatenate( - loser_offsets_boot) - loser_physicals_boot = np.concatenate( - loser_physicals_boot) - - percs = [5, 50, 95] - winner_onsets_boot_quarts = np.percentile( - winner_onsets_boot, percs, axis=0) - winner_offsets_boot_quarts = np.percentile( - winner_offsets_boot, percs, axis=0) - winner_physicals_boot_quarts = np.percentile( - winner_physicals_boot, percs, axis=0) - loser_onsets_boot_quarts = np.percentile( - loser_onsets_boot, percs, axis=0) - loser_offsets_boot_quarts = np.percentile( - loser_offsets_boot, percs, axis=0) - loser_physicals_boot_quarts = np.percentile( - loser_physicals_boot, percs, axis=0) - - fig, ax = plt.subplots(2, 3, figsize=( - 21*ps.cm, 10*ps.cm), sharey=True, sharex=True) - - ax[0, 0].plot(kde_time, winner_onsets_conv) - ax[0, 1].plot(kde_time, winner_offsets_conv) - ax[0, 2].plot(kde_time, winner_physicals_conv) - ax[1, 0].plot(kde_time, loser_onsets_conv) - ax[1, 1].plot(kde_time, loser_offsets_conv) - ax[1, 2].plot(kde_time, loser_physicals_conv) - - ax[0, 0].plot(kde_time, winner_onsets_boot_quarts[1], c=ps.black) - ax[0, 1].plot(kde_time, winner_offsets_boot_quarts[1], c=ps.black) - ax[0, 2].plot(kde_time, winner_physicals_boot_quarts[1], c=ps.black) - ax[1, 0].plot(kde_time, loser_onsets_boot_quarts[1], c=ps.black) - ax[1, 1].plot(kde_time, loser_offsets_boot_quarts[1], c=ps.black) - ax[1, 2].plot(kde_time, loser_physicals_boot_quarts[1], c=ps.black) + # ax[0, 0].set_xlim(-30, 30) + plt.show() + + # winner_onsets = np.sort(flatten(winner_onsets)) + # winner_offsets = np.sort(flatten(winner_offsets)) + # winner_physicals = np.sort(flatten(winner_physicals)) + # loser_onsets = np.sort(flatten(loser_onsets)) + # loser_offsets = np.sort(flatten(loser_offsets)) + # loser_physicals = np.sort(flatten(loser_physicals)) + + # winner_onsets_conv = acausal_kde1d( + # winner_onsets, kde_time, kernel_width) + # winner_offsets_conv = acausal_kde1d( + # winner_offsets, kde_time, kernel_width) + # winner_physicals_conv = acausal_kde1d( + # winner_physicals, kde_time, kernel_width) + # loser_onsets_conv = acausal_kde1d( + # loser_onsets, kde_time, kernel_width) + # loser_offsets_conv = acausal_kde1d( + # loser_offsets, kde_time, kernel_width) + # loser_physicals_conv = acausal_kde1d( + # loser_physicals, kde_time, kernel_width) + + # winner_onsets_conv = winner_onsets_conv / onset_count + # winner_offsets_conv = winner_offsets_conv / offset_count + # winner_physicals_conv = winner_physicals_conv / physical_count + # loser_onsets_conv = loser_onsets_conv / onset_count + # loser_offsets_conv = loser_offsets_conv / offset_count + # loser_physicals_conv = loser_physicals_conv / physical_count + + # winner_onsets_boot = np.concatenate( + # winner_onsets_boot) + # winner_offsets_boot = np.concatenate( + # winner_offsets_boot) + # winner_physicals_boot = np.concatenate( + # winner_physicals_boot) + # loser_onsets_boot = np.concatenate( + # loser_onsets_boot) + # loser_offsets_boot = np.concatenate( + # loser_offsets_boot) + # loser_physicals_boot = np.concatenate( + # loser_physicals_boot) + + # percs = [5, 50, 95] + # winner_onsets_boot_quarts = np.percentile( + # winner_onsets_boot, percs, axis=0) + # winner_offsets_boot_quarts = np.percentile( + # winner_offsets_boot, percs, axis=0) + # winner_physicals_boot_quarts = np.percentile( + # winner_physicals_boot, percs, axis=0) + # loser_onsets_boot_quarts = np.percentile( + # loser_onsets_boot, percs, axis=0) + # loser_offsets_boot_quarts = np.percentile( + # loser_offsets_boot, percs, axis=0) + # loser_physicals_boot_quarts = np.percentile( + # loser_physicals_boot, percs, axis=0) + + # fig, ax = plt.subplots(2, 3, figsize=( + # 21*ps.cm, 10*ps.cm), sharey=True, sharex=True) + + # ax[0, 0].plot(kde_time, winner_onsets_conv) + # ax[0, 1].plot(kde_time, winner_offsets_conv) + # ax[0, 2].plot(kde_time, winner_physicals_conv) + # ax[1, 0].plot(kde_time, loser_onsets_conv) + # ax[1, 1].plot(kde_time, loser_offsets_conv) + # ax[1, 2].plot(kde_time, loser_physicals_conv) + + # ax[0, 0].plot(kde_time, winner_onsets_boot_quarts[1], c=ps.black) + # ax[0, 1].plot(kde_time, winner_offsets_boot_quarts[1], c=ps.black) + # ax[0, 2].plot(kde_time, winner_physicals_boot_quarts[1], c=ps.black) + # ax[1, 0].plot(kde_time, loser_onsets_boot_quarts[1], c=ps.black) + # ax[1, 1].plot(kde_time, loser_offsets_boot_quarts[1], c=ps.black) + # ax[1, 2].plot(kde_time, loser_physicals_boot_quarts[1], c=ps.black) # for kde in winner_onsets_boot: # ax[0, 0].plot(kde_time, kde, @@ -428,43 +483,43 @@ def main(dataroot): # ax[1, 2].plot(kde_time, kde, # color='gray') - ax[0, 0].fill_between(kde_time, - winner_onsets_boot_quarts[0], - winner_onsets_boot_quarts[2], - color=ps.gray, - alpha=0.5) - - ax[0, 1].fill_between(kde_time, - winner_offsets_boot_quarts[0], - winner_offsets_boot_quarts[2], - color=ps.gray, - alpha=0.5) - - ax[0, 2].fill_between(kde_time, - loser_physicals_boot_quarts[0], - loser_physicals_boot_quarts[2], - color=ps.gray, - alpha=0.5) - - ax[1, 0].fill_between(kde_time, - loser_onsets_boot_quarts[0], - loser_onsets_boot_quarts[2], - color=ps.gray, - alpha=0.5) - - ax[1, 1].fill_between(kde_time, - loser_offsets_boot_quarts[0], - loser_offsets_boot_quarts[2], - color=ps.gray, - alpha=0.5) - - ax[1, 2].fill_between(kde_time, - loser_physicals_boot_quarts[0], - loser_physicals_boot_quarts[2], - color=ps.gray, - alpha=0.5) - - plt.show() + # ax[0, 0].fill_between(kde_time, + # winner_onsets_boot_quarts[0], + # winner_onsets_boot_quarts[2], + # color=ps.gray, + # alpha=0.5) + + # ax[0, 1].fill_between(kde_time, + # winner_offsets_boot_quarts[0], + # winner_offsets_boot_quarts[2], + # color=ps.gray, + # alpha=0.5) + + # ax[0, 2].fill_between(kde_time, + # loser_physicals_boot_quarts[0], + # loser_physicals_boot_quarts[2], + # color=ps.gray, + # alpha=0.5) + + # ax[1, 0].fill_between(kde_time, + # loser_onsets_boot_quarts[0], + # loser_onsets_boot_quarts[2], + # color=ps.gray, + # alpha=0.5) + + # ax[1, 1].fill_between(kde_time, + # loser_offsets_boot_quarts[0], + # loser_offsets_boot_quarts[2], + # color=ps.gray, + # alpha=0.5) + + # ax[1, 2].fill_between(kde_time, + # loser_physicals_boot_quarts[0], + # loser_physicals_boot_quarts[2], + # color=ps.gray, + # alpha=0.5) + + # plt.show() if __name__ == '__main__': diff --git a/poster/figs/efishlogo.pdf b/poster/figs/efishlogo.pdf index 95372e3..eff014a 100644 Binary files a/poster/figs/efishlogo.pdf and b/poster/figs/efishlogo.pdf differ diff --git a/poster/figs/introplot.pdf b/poster/figs/introplot.pdf index 7fef6fa..6bcc304 100644 Binary files a/poster/figs/introplot.pdf and b/poster/figs/introplot.pdf differ diff --git a/poster/main.tex b/poster/main.tex index 85c9838..1ac138e 100644 --- a/poster/main.tex +++ b/poster/main.tex @@ -16,21 +16,22 @@ blockverticalspace=2mm, colspace=20mm, subcolspace=0mm]{tikzposter} %Default val \begin{columns} \column{0.4} -\myblock[GrayBlock]{Introduction}{ +\myblock[TranspBlock]{Introduction}{ The time-frequency tradeoff makes reliable signal detecion and simultaneous sender identification by simple Fourier decomposition in freely interacting weakly electric fish impossible. This profoundly limits our current understanding of chirps to experiments with single - or physically separated - individuals. + \vspace{1cm} \begin{tikzfigure}[] \label{griddrawing} - \includegraphics[width=0.6\linewidth]{figs/introplot} + \includegraphics[width=\linewidth]{figs/introplot} \end{tikzfigure} } \myblock[TranspBlock]{Chirp detection}{ \begin{tikzfigure}[] \label{fig:alg1} - \includegraphics[width=0.6\linewidth]{figs/algorithm1} + \includegraphics[width=0.9\linewidth]{figs/algorithm1} \end{tikzfigure} \vspace{2cm} \begin{tikzfigure}[] diff --git a/poster/style.tex b/poster/style.tex index da09710..a6d2f2b 100644 --- a/poster/style.tex +++ b/poster/style.tex @@ -33,8 +33,8 @@ \begin{minipage}[c]{0.2\paperwidth} \centering % \vspace{1cm} - \hspace{-10cm} - \includegraphics[width=0.8\linewidth]{figs/efishlogo.pdf} + \hspace{-7cm} + \includegraphics[width=0.7\linewidth]{figs/efishlogo.pdf} \end{minipage}} % \begin{minipage}[c]{0.2\paperwidth} % \vspace{1cm}\hspace{1cm}