fix branches

zsh:1: command not found: q

code/behavior.py

@@ -1,4 +1,5 @@
 import os 
+import os 
 
 import numpy as np
 import matplotlib.pyplot as plt 
@@ -6,6 +7,7 @@ import matplotlib.pyplot as plt
 from IPython import embed
 from pandas import read_csv
 from modules.logger import makeLogger
+from scipy.ndimage import gaussian_filter1d
 
 logger = makeLogger(__name__)
 
@@ -106,7 +108,6 @@ def correct_chasing_events(
         logger.info('Chasing events are equal')
         return category, timestamps
 
-
     # Correct the wrong chasing events; delete double events
     wrong_ids = []
     for i in range(len(longer_array)-(len_diff+1)):
@@ -123,6 +124,31 @@ def correct_chasing_events(
     return category, timestamps
 
 
+def event_triggered_chirps(
+    event: np.ndarray, 
+    chirps:np.ndarray,
+    time_before_event: int,
+    time_after_event: int
+    )-> tuple[np.ndarray, np.ndarray]:
+
+
+    event_chirps = []   # chirps that are in specified window around event
+    centered_chirps = []    # timestamps of chirps around event centered on the event timepoint
+
+    for event_timestamp in event:
+        start = event_timestamp - time_before_event    # timepoint of window start
+        stop = event_timestamp + time_after_event    # timepoint of window ending
+        chirps_around_event = [c for c in chirps if (c >= start) & (c <= stop)]     # get chirps that are in a -5 to +5 sec window around event
+        event_chirps.append(chirps_around_event)
+        if len(chirps_around_event) == 0:
+            continue
+        else: 
+            centered_chirps.append(chirps_around_event - event_timestamp)
+    centered_chirps = np.concatenate(centered_chirps, axis=0)   # convert list of arrays to one array for plotting
+
+    return event_chirps, centered_chirps
+
+
 def main(datapath: str):
 
     # behavior is pandas dataframe with all the data
@@ -144,11 +170,6 @@ def main(datapath: str):
     chasing_offset = timestamps[category == 1]
     physical_contact = timestamps[category == 2]
 
-    ##### TODO Physical contact-triggered chirps (PTC) mit Rasterplot #####
-    # Wahrscheinlichkeit von Phys auf Ch und vice versa
-    # Chasing-triggered chirps (CTC) mit Rasterplot
-    # Wahrscheinlichkeit von Chase auf Ch und vice versa
-
     # First overview plot
     fig1, ax1 = plt.subplots()
     ax1.scatter(chirps, np.ones_like(chirps), marker='*', color='royalblue', label='Chirps')
@@ -160,13 +181,50 @@ def main(datapath: str):
     plt.close()
 
     # Get fish ids
-    all_fish_ids = np.unique(chirps_fish_ids)
+    fish_ids = np.unique(chirps_fish_ids)
+
+    ##### Chasing triggered chirps CTC #####
+    # Evaluate how many chirps were emitted in specific time window around the chasing onset events
+
+    # Iterate over chasing onsets (later over fish)
+    time_around_event = 5    # time window around the event in which chirps are counted, 5 = -5 to +5 sec around event
+    #### Loop crashes at concatenate in function ####
+    # for i in range(len(fish_ids)):
+    #     fish = fish_ids[i]
+    #     chirps = chirps[chirps_fish_ids == fish]
+    #     print(fish)
+
+    chasing_chirps, centered_chasing_chirps = event_triggered_chirps(chasing_onset, chirps, time_around_event, time_around_event)
+    physical_chirps, centered_physical_chirps = event_triggered_chirps(physical_contact, chirps, time_around_event, time_around_event)
+
+    # Kernel density estimation ???
+    # centered_chasing_chirps_convolved = gaussian_filter1d(centered_chasing_chirps, 5)
+    
+    # centered_chasing = chasing_onset[0] - chasing_onset[0]   ## get the 0 timepoint for plotting; set one chasing event to 0
+    offsets = [0.5, 1]
+    fig4, ax4 = plt.subplots(figsize=(20 / 2.54, 12 / 2.54), constrained_layout=True)
+    ax4.eventplot(np.array([centered_chasing_chirps, centered_physical_chirps]), lineoffsets=offsets, linelengths=0.25, colors=['g', 'r'])
+    ax4.vlines(0, 0, 1.5, 'tab:grey', 'dashed', 'Timepoint of event')
+    # ax4.plot(centered_chasing_chirps_convolved)
+    ax4.set_yticks(offsets)
+    ax4.set_yticklabels(['Chasings', 'Physical \n contacts'])
+    ax4.set_xlabel('Time[s]')
+    ax4.set_ylabel('Type of event')
+    plt.show()
 
     # Associate chirps to inidividual fish
-    fish1 = chirps[chirps_fish_ids == all_fish_ids[0]]
-    fish2 = chirps[chirps_fish_ids == all_fish_ids[1]]
+    fish1 = chirps[chirps_fish_ids == fish_ids[0]]
+    fish2 = chirps[chirps_fish_ids == fish_ids[1]]
     fish = [len(fish1), len(fish2)]
 
+    ### Plots:
+    # 1. All recordings, all fish, all chirps
+        # One CTC, one PTC
+    # 2. All recordings, only winners
+        # One CTC, one PTC
+    # 3. All recordings, all losers
+        # One CTC, one PTC
+
     #### Chirp counts per fish general #####
     fig2, ax2 = plt.subplots()
     x = ['Fish1', 'Fish2']
@@ -196,22 +254,20 @@ def main(datapath: str):
     fig3 , ax3 = plt.subplots()
     ax3.bar(['Chirps in chasing events',  'Chasing events without Chirps'], [counts_chirps_chasings, chasings_without_chirps], width=width)
     plt.ylabel('Count')
-    plt.show()
+    # plt.show()
     plt.close()  
 
-    # comparison between chasing events with and without chirps  
-
-
-
+    # comparison between chasing events with and without chirps
 
 
+    
     embed()
-
-
+    exit()
 
 
 
 if __name__ == '__main__':
     # Path to the data
     datapath = '../data/mount_data/2020-05-13-10_00/'
+    datapath = '../data/mount_data/2020-05-13-10_00/'
     main(datapath)

code/chirpdetection.py

@@ -102,7 +102,7 @@ class ChirpPlotBuffer:
         self.t0 = 0
 
         fig = plt.figure(
-            figsize=(14 / 2.54, 20 / 2.54)
+            figsize=(14 * ps.cm, 18 * ps.cm)
         )
 
         gs0 = gr.GridSpec(
@@ -133,8 +133,10 @@ class ChirpPlotBuffer:
             data_oi,
             self.data.raw_rate,
             self.t0 - 5,
-            [np.min(self.frequency) - 100, np.max(self.frequency) + 200]
+            [np.min(self.frequency) - 300, np.max(self.frequency) + 300]
         )
+        ax0.set_ylim(np.min(self.frequency) - 100,
+                     np.max(self.frequency) + 200)
 
         for track_id in self.data.ids:
 
@@ -157,27 +159,35 @@ class ChirpPlotBuffer:
                          zorder=10, color=ps.gblue1)
             else:
                 ax0.plot(t-self.t0_old, f, lw=lw,
-                         zorder=10, color=ps.gray, alpha=0.5)
+                         zorder=10, color=ps.black)
 
-        ax0.fill_between(
-            np.arange(self.t0, self.t0 + self.dt, 1 / self.data.raw_rate),
-            q50 - self.config.minimal_bandwidth / 2,
-            q50 + self.config.minimal_bandwidth / 2,
-            color=ps.gblue1,
-            lw=1,
-            ls="dashed",
-            alpha=0.5,
-        )
+        # ax0.fill_between(
+        #     np.arange(self.t0, self.t0 + self.dt, 1 / self.data.raw_rate),
+        #     q50 - self.config.minimal_bandwidth / 2,
+        #     q50 + self.config.minimal_bandwidth / 2,
+        #     color=ps.gblue1,
+        #     lw=1,
+        #     ls="dashed",
+        #     alpha=0.5,
+        # )
+
+        # ax0.fill_between(
+        #     np.arange(self.t0, self.t0 + self.dt, 1 / self.data.raw_rate),
+        #     search_lower,
+        #     search_upper,
+        #     color=ps.gblue2,
+        #     lw=1,
+        #     ls="dashed",
+        #     alpha=0.5,
+        # )
+
+        ax0.axhline(q50 - self.config.minimal_bandwidth / 2,
+                    color=ps.gblue1, lw=1, ls="dashed")
+        ax0.axhline(q50 + self.config.minimal_bandwidth / 2,
+                    color=ps.gblue1, lw=1, ls="dashed")
+        ax0.axhline(search_lower, color=ps.gblue2, lw=1, ls="dashed")
+        ax0.axhline(search_upper, color=ps.gblue2, lw=1, ls="dashed")
 
-        ax0.fill_between(
-            np.arange(self.t0, self.t0 + self.dt, 1 / self.data.raw_rate),
-            search_lower,
-            search_upper,
-            color=ps.gblue2,
-            lw=1,
-            ls="dashed",
-            alpha=0.5,
-        )
         # ax0.axhline(q50, spec_times[0], spec_times[-1],
         #             color=ps.gblue1, lw=2, ls="dashed")
         # ax0.axhline(q50 + self.search_frequency,
@@ -187,7 +197,11 @@ class ChirpPlotBuffer:
         if len(chirps) > 0:
             for chirp in chirps:
                 ax0.scatter(
-                    chirp, np.median(self.frequency) + 150, c=ps.black, marker="v"
+                    chirp, np.median(self.frequency), c=ps.red, marker=".",
+                    edgecolors=ps.red,
+                    facecolors=ps.red,
+                    zorder=10,
+                    s=70,
                 )
 
         # plot waveform of filtered signal
@@ -207,25 +221,31 @@ class ChirpPlotBuffer:
                  c=ps.gblue3, lw=lw, label="baseline inst. freq.")
 
         # plot filtered and rectified envelope
-        ax4.plot(self.time, self.baseline_envelope, c=ps.gblue1, lw=lw)
+        ax4.plot(self.time, self.baseline_envelope *
+                 waveform_scaler, c=ps.gblue1, lw=lw)
         ax4.scatter(
             (self.time)[self.baseline_peaks],
-            self.baseline_envelope[self.baseline_peaks],
+            (self.baseline_envelope*waveform_scaler)[self.baseline_peaks],
             edgecolors=ps.red,
+            facecolors=ps.red,
             zorder=10,
-            marker="o",
-            facecolors="none",
+            marker=".",
+            s=70,
+            # facecolors="none",
         )
 
         # plot envelope of search signal
-        ax5.plot(self.time, self.search_envelope, c=ps.gblue2, lw=lw)
+        ax5.plot(self.time, self.search_envelope *
+                 waveform_scaler, c=ps.gblue2, lw=lw)
         ax5.scatter(
             (self.time)[self.search_peaks],
-            self.search_envelope[self.search_peaks],
+            (self.search_envelope*waveform_scaler)[self.search_peaks],
             edgecolors=ps.red,
+            facecolors=ps.red,
             zorder=10,
-            marker="o",
-            facecolors="none",
+            marker=".",
+            s=70,
+            # facecolors="none",
         )
 
         # plot filtered instantaneous frequency
@@ -235,16 +255,20 @@ class ChirpPlotBuffer:
             self.frequency_time[self.frequency_peaks],
             self.frequency_filtered[self.frequency_peaks],
             edgecolors=ps.red,
+            facecolors=ps.red,
             zorder=10,
-            marker="o",
-            facecolors="none",
+            marker=".",
+            s=70,
+            # facecolors="none",
         )
 
         ax0.set_ylabel("frequency [Hz]")
-        ax1.set_ylabel("a.u.")
-        ax2.set_ylabel("a.u.")
+        ax1.set_ylabel(r"$\mu$V")
+        ax2.set_ylabel(r"$\mu$V")
         ax3.set_ylabel("Hz")
-        ax5.set_ylabel("a.u.")
+        ax4.set_ylabel(r"$\mu$V")
+        ax5.set_ylabel(r"$\mu$V")
+        ax6.set_ylabel("Hz")
         ax6.set_xlabel("time [s]")
 
         plt.setp(ax0.get_xticklabels(), visible=False)
@@ -323,7 +347,7 @@ def plot_spectrogram(
         aspect="auto",
         origin="lower",
         interpolation="gaussian",
-        alpha=0.6,
+        # alpha=0.6,
     )
     # axis.use_sticky_edges = False
     return spec_times
@@ -628,7 +652,7 @@ def chirpdetection(datapath: str, plot: str, debug: str = 'false') -> None:
     raw_time = np.arange(data.raw.shape[0]) / data.raw_rate
 
     # good chirp times for data: 2022-06-02-10_00
-    # window_start_index = (3 * 60 * 60 + 6 * 60 + 43.5 + 5) * data.raw_rate
+    # window_start_index = (3 * 60 * 60 + 6 * 60 + 43.5) * data.raw_rate
     # window_duration_index = 60 * data.raw_rate
 
     #     t0 = 0
@@ -651,7 +675,7 @@ def chirpdetection(datapath: str, plot: str, debug: str = 'false') -> None:
     multiwindow_chirps = []
     multiwindow_ids = []
 
-    for st, window_start_index in enumerate(window_start_indices):
+    for st, window_start_index in enumerate(window_start_indices[3175:]):
 
         logger.info(f"Processing window {st+1} of {len(window_start_indices)}")
 
@@ -1097,4 +1121,4 @@ if __name__ == "__main__":
     datapath = "../data/2022-06-02-10_00/"
     # datapath = "/home/weygoldt/Data/uni/efishdata/2016-colombia/fishgrid/2016-04-09-22_25/"
     # datapath = "/home/weygoldt/Data/uni/chirpdetection/GP2023_chirp_detection/data/mount_data/2020-03-13-10_00/"
-    chirpdetection(datapath, plot="show", debug="false")
+    chirpdetection(datapath, plot="save", debug="false")

code/eventchirpsplots.py

@@ -0,0 +1,522 @@
+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.plotstyle import PlotStyle
+from modules.datahandling import causal_kde1d, acausal_kde1d
+
+logger = makeLogger(__name__)
+ps = PlotStyle()
+
+class Behavior:
+    """Load behavior data from csv file as class attributes
+        Attributes
+    ----------
+    behavior: 0: chasing onset, 1: chasing offset, 2: physical contact
+    behavior_type:         
+    behavioral_category:   
+    comment_start:         
+    comment_stop:          
+    dataframe: pandas dataframe with all the data            
+    duration_s:             
+    media_file:            
+    observation_date:      
+    observation_id:        
+    start_s: start time of the event in seconds               
+    stop_s:  stop time of the event in seconds               
+    total_length:          
+    """
+
+    def __init__(self, folder_path: str) -> None:
+        print(f'{folder_path}')
+        LED_on_time_BORIS = np.load(os.path.join(folder_path, 'LED_on_time.npy'), allow_pickle=True)
+        self.time = np.load(os.path.join(folder_path, "times.npy"), allow_pickle=True)
+        csv_filename = [f for f in os.listdir(folder_path) if f.endswith('.csv')][0] # check if there are more than one csv file
+        self.dataframe = read_csv(os.path.join(folder_path, csv_filename))
+        self.chirps = np.load(os.path.join(folder_path, 'chirps.npy'), allow_pickle=True)
+        self.chirps_ids = np.load(os.path.join(folder_path, 'chirp_ids.npy'), allow_pickle=True)
+
+        for k, key in enumerate(self.dataframe.keys()):
+            key = key.lower() 
+            if ' ' in key:
+                key = key.replace(' ', '_')
+                if '(' in key:
+                    key = key.replace('(', '')
+                    key = key.replace(')', '')
+            setattr(self, key, np.array(self.dataframe[self.dataframe.keys()[k]]))
+
+        last_LED_t_BORIS = LED_on_time_BORIS[-1]
+        real_time_range = self.time[-1] - self.time[0]
+        factor = 1.034141
+        shift = last_LED_t_BORIS - real_time_range * factor
+        self.start_s = (self.start_s - shift) / factor
+        self.stop_s = (self.stop_s - shift) / factor
+
+"""
+1 - chasing onset
+2 - chasing offset
+3 - physical contact event
+
+temporal encpding needs to be corrected ... not exactly 25FPS.
+
+### correspinding python code ###
+
+    factor = 1.034141
+    LED_on_time_BORIS = np.load(os.path.join(folder_path, 'LED_on_time.npy'), allow_pickle=True)
+    last_LED_t_BORIS = LED_on_time_BORIS[-1]
+    real_time_range = times[-1] - times[0]
+    shift = last_LED_t_BORIS - real_time_range * factor
+
+    data = pd.read_csv(os.path.join(folder_path, file[1:-7] + '.csv'))
+    boris_times = data['Start (s)']
+    data_times = []
+
+    for Cevent_t in boris_times:
+        Cevent_boris_times = (Cevent_t - shift) / factor
+        data_times.append(Cevent_boris_times)
+
+    data_times = np.array(data_times)
+    behavior = data['Behavior']
+"""
+
+
+def correct_chasing_events(
+    category: np.ndarray, 
+    timestamps: np.ndarray
+    ) -> tuple[np.ndarray, np.ndarray]:
+
+    onset_ids = np.arange(
+        len(category))[category == 0]
+    offset_ids = np.arange(
+        len(category))[category == 1]
+
+    wrong_bh = np.arange(len(category))[category!=2][:-1][np.diff(category[category!=2])==0]
+    if onset_ids[0] > offset_ids[0]:
+        offset_ids = np.delete(offset_ids, 0)
+        help_index = offset_ids[0]
+        wrong_bh = np.append(wrong_bh[help_index])
+
+    category = np.delete(category, wrong_bh)
+    timestamps = np.delete(timestamps, wrong_bh)
+
+
+    # Check whether on- or offset is longer and calculate length difference
+    if len(onset_ids) > len(offset_ids):
+        len_diff = len(onset_ids) - len(offset_ids)
+        logger.info(f'Onsets are greater than offsets by {len_diff}')
+    elif len(onset_ids) < len(offset_ids):
+        len_diff = len(offset_ids) - len(onset_ids)
+        logger.info(f'Offsets are greater than onsets by {len_diff}')
+    elif len(onset_ids) == len(offset_ids):
+        logger.info('Chasing events are equal')
+    
+    return category, timestamps
+
+
+def event_triggered_chirps(
+    event: np.ndarray, 
+    chirps:np.ndarray,
+    time_before_event: int,
+    time_after_event: int,
+    dt: float,
+    width: float,
+    )-> tuple[np.ndarray, np.ndarray, np.ndarray]:
+
+    event_chirps = []   # chirps that are in specified window around event
+    centered_chirps = []    # timestamps of chirps around event centered on the event timepoint
+
+    for event_timestamp in event:
+        start = event_timestamp - time_before_event
+        stop = event_timestamp + time_after_event
+        chirps_around_event = [c for c in chirps if (c >= start) & (c <= stop)]
+        event_chirps.append(chirps_around_event)
+        if len(chirps_around_event) == 0:
+            continue
+        else: 
+            centered_chirps.append(chirps_around_event - event_timestamp)
+    
+    time = np.arange(-time_before_event, time_after_event, dt)
+    
+    # Kernel density estimation with some if's
+    if len(centered_chirps) == 0:
+        centered_chirps = np.array([])
+        centered_chirps_convolved = np.zeros(len(time))
+    else:
+        centered_chirps = np.concatenate(centered_chirps, axis=0)   # convert list of arrays to one array for plotting
+        centered_chirps_convolved = (acausal_kde1d(centered_chirps, time, width)) / len(event)
+
+    return event_chirps, centered_chirps, centered_chirps_convolved
+
+
+def main(datapath: str):
+
+    foldernames = [datapath + x + '/' for x in os.listdir(datapath) if os.path.isdir(datapath + x)]
+
+    nrecording_chirps = []
+    nrecording_chirps_fish_ids = []
+    nrecording_chasing_onsets = []
+    nrecording_chasing_offsets = []
+    nrecording_physicals = []
+
+    # Iterate over all recordings and save chirp- and event-timestamps
+    for folder in foldernames:
+        # exclude folder with empty LED_on_time.npy
+        if folder == '../data/mount_data/2020-05-12-10_00/':
+            continue
+
+        bh = Behavior(folder)
+        
+        # Chirps are already sorted
+        category = bh.behavior
+        timestamps = bh.start_s
+        chirps = bh.chirps
+        nrecording_chirps.append(chirps)
+        chirps_fish_ids = bh.chirps_ids
+        nrecording_chirps_fish_ids.append(chirps_fish_ids)
+        fish_ids = np.unique(chirps_fish_ids)
+
+        # Correct for doubles in chasing on- and offsets to get the right on-/offset pairs
+        # Get rid of tracking faults (two onsets or two offsets after another)
+        category, timestamps = correct_chasing_events(category, timestamps)
+
+        # Split categories
+        chasing_onsets = timestamps[category == 0]
+        nrecording_chasing_onsets.append(chasing_onsets)
+        chasing_offsets = timestamps[category == 1]
+        nrecording_chasing_offsets.append(chasing_offsets)
+        physical_contacts = timestamps[category == 2]
+        nrecording_physicals.append(physical_contacts)
+    
+
+    # Define time window for chirps around event analysis
+    time_before_event = 30
+    time_after_event = 60
+    dt = 0.01
+    width = 1.5   # width of kernel for all recordings, currently gaussian kernel
+    recording_width = 2 # width of kernel for each recording
+    time = np.arange(-time_before_event, time_after_event, dt)
+
+    ##### Chirps around events, all fish, all recordings #####
+    # Centered chirps per event type
+    nrecording_centered_onset_chirps = []
+    nrecording_centered_offset_chirps = []
+    nrecording_centered_physical_chirps = []
+    # Bootstrapped chirps per recording and per event: 27[1000[n]] 27 recs, 1000 shuffles, n chirps
+    nrecording_shuffled_convolved_onset_chirps = []
+    nrecording_shuffled_convolved_offset_chirps = []
+    nrecording_shuffled_convolved_physical_chirps = []
+
+    nbootstrapping = 10
+
+    for i in range(len(nrecording_chirps)):
+        chirps = nrecording_chirps[i]
+        chasing_onsets = nrecording_chasing_onsets[i]
+        chasing_offsets = nrecording_chasing_offsets[i]
+        physical_contacts = nrecording_physicals[i]
+
+        # Chirps around chasing onsets
+        _, centered_chasing_onset_chirps, cc_chasing_onset_chirps = event_triggered_chirps(chasing_onsets, chirps, time_before_event, time_after_event, dt, recording_width)
+        # Chirps around chasing offsets
+        _, centered_chasing_offset_chirps, cc_chasing_offset_chirps = event_triggered_chirps(chasing_offsets, chirps, time_before_event, time_after_event, dt, recording_width)
+        # Chirps around physical contacts
+        _, centered_physical_chirps, cc_physical_chirps = event_triggered_chirps(physical_contacts, chirps, time_before_event, time_after_event, dt, recording_width)
+
+        nrecording_centered_onset_chirps.append(centered_chasing_onset_chirps)
+        nrecording_centered_offset_chirps.append(centered_chasing_offset_chirps)
+        nrecording_centered_physical_chirps.append(centered_physical_chirps)
+
+        ## Shuffled chirps ##
+        nshuffled_onset_chirps = []
+        nshuffled_offset_chirps = []
+        nshuffled_physical_chirps = []
+
+        for j in tqdm(range(nbootstrapping)):
+        # Calculate interchirp intervals; add first chirp timestamp in beginning to get equal lengths
+            interchirp_intervals = np.append(np.array([chirps[0]]), np.diff(chirps))
+            np.random.shuffle(interchirp_intervals)
+            shuffled_chirps = np.cumsum(interchirp_intervals)
+            # Shuffled chasing onset chirps
+            _, _, cc_shuffled_onset_chirps = event_triggered_chirps(chasing_onsets, shuffled_chirps, time_before_event, time_after_event, dt, recording_width)
+            nshuffled_onset_chirps.append(cc_shuffled_onset_chirps)
+            # Shuffled chasing offset chirps
+            _, _, cc_shuffled_offset_chirps = event_triggered_chirps(chasing_offsets, shuffled_chirps, time_before_event, time_after_event, dt, recording_width)
+            nshuffled_offset_chirps.append(cc_shuffled_offset_chirps)
+            # Shuffled physical contact chirps
+            _, _, cc_shuffled_physical_chirps = event_triggered_chirps(physical_contacts, shuffled_chirps, time_before_event, time_after_event, dt, recording_width)
+            nshuffled_physical_chirps.append(cc_shuffled_physical_chirps)
+
+        rec_shuffled_q5_onset, rec_shuffled_median_onset, rec_shuffled_q95_onset = np.percentile(
+        nshuffled_onset_chirps, (5, 50, 95), axis=0)
+        rec_shuffled_q5_offset, rec_shuffled_median_offset, rec_shuffled_q95_offset = np.percentile(
+        nshuffled_offset_chirps, (5, 50, 95), axis=0)
+        rec_shuffled_q5_physical, rec_shuffled_median_physical, rec_shuffled_q95_physical = np.percentile(
+        nshuffled_physical_chirps, (5, 50, 95), axis=0)
+
+        #### Recording plots ####
+        fig, ax = plt.subplots(1, 3, figsize=(28*ps.cm, 16*ps.cm, ), constrained_layout=True, sharey='all')
+        ax[0].set_xlabel('Time[s]')
+
+        # Plot chasing onsets
+        ax[0].set_ylabel('Chirp rate [Hz]')
+        ax[0].plot(time, cc_chasing_onset_chirps, color=ps.yellow, zorder=2)
+        ax0 = ax[0].twinx()
+        ax0.eventplot(centered_chasing_onset_chirps, linelengths=0.2, colors=ps.gray, alpha=0.25, zorder=1)
+        ax0.vlines(0, 0, 1.5, ps.white, 'dashed')
+        ax[0].set_zorder(ax0.get_zorder()+1)
+        ax[0].patch.set_visible(False)
+        ax0.set_yticklabels([])
+        ax0.set_yticks([])
+        ax[0].fill_between(time, rec_shuffled_q5_onset, rec_shuffled_q95_onset, color=ps.gray, alpha=0.5)
+        ax[0].plot(time, rec_shuffled_median_onset, color=ps.black)
+
+        # Plot chasing offets
+        ax[1].set_xlabel('Time[s]')
+        ax[1].plot(time, cc_chasing_offset_chirps, color=ps.orange, zorder=2)
+        ax1 = ax[1].twinx()
+        ax1.eventplot(centered_chasing_offset_chirps, linelengths=0.2, colors=ps.gray, alpha=0.25, zorder=1)
+        ax1.vlines(0, 0, 1.5, ps.white, 'dashed')
+        ax[1].set_zorder(ax1.get_zorder()+1)
+        ax[1].patch.set_visible(False)
+        ax1.set_yticklabels([])
+        ax1.set_yticks([])
+        ax[1].fill_between(time, rec_shuffled_q5_offset, rec_shuffled_q95_offset, color=ps.gray, alpha=0.5)
+        ax[1].plot(time, rec_shuffled_median_offset, color=ps.black)
+
+        # Plot physical contacts
+        ax[2].set_xlabel('Time[s]')
+        ax[2].plot(time, cc_physical_chirps, color=ps.maroon, zorder=2)
+        ax2 = ax[2].twinx()
+        ax2.eventplot(centered_physical_chirps, linelengths=0.2, colors=ps.gray, alpha=0.25, zorder=1)
+        ax2.vlines(0, 0, 1.5, ps.white, 'dashed')
+        ax[2].set_zorder(ax2.get_zorder()+1)
+        ax[2].patch.set_visible(False)
+        ax2.set_yticklabels([])
+        ax2.set_yticks([])
+        ax[2].fill_between(time, rec_shuffled_q5_physical, rec_shuffled_q95_physical, color=ps.gray, alpha=0.5)
+        ax[2].plot(time, rec_shuffled_median_physical, ps.black)
+        fig.suptitle(f'Recording: {i}')
+        plt.show()
+        # plt.close()
+        
+        nrecording_shuffled_convolved_onset_chirps.append(nshuffled_onset_chirps)
+        nrecording_shuffled_convolved_offset_chirps.append(nshuffled_offset_chirps)
+        nrecording_shuffled_convolved_physical_chirps.append(nshuffled_physical_chirps)
+
+    #  vstack um 1. Dim zu cutten
+    nrecording_shuffled_convolved_onset_chirps = np.vstack(nrecording_shuffled_convolved_onset_chirps)
+    nrecording_shuffled_convolved_offset_chirps = np.vstack(nrecording_shuffled_convolved_offset_chirps)
+    nrecording_shuffled_convolved_physical_chirps = np.vstack(nrecording_shuffled_convolved_physical_chirps)
+    
+    shuffled_q5_onset, shuffled_median_onset, shuffled_q95_onset = np.percentile(
+        nrecording_shuffled_convolved_onset_chirps, (5, 50, 95), axis=0)
+    shuffled_q5_offset, shuffled_median_offset, shuffled_q95_offset = np.percentile(
+        nrecording_shuffled_convolved_offset_chirps, (5, 50, 95), axis=0)
+    shuffled_q5_physical, shuffled_median_physical, shuffled_q95_physical = np.percentile(
+        nrecording_shuffled_convolved_physical_chirps, (5, 50, 95), axis=0)
+
+    # Flatten all chirps 
+    all_chirps = np.concatenate(nrecording_chirps).ravel()  # not centered
+
+    # Flatten event timestamps
+    all_onsets = np.concatenate(nrecording_chasing_onsets).ravel() # not centered
+    all_offsets = np.concatenate(nrecording_chasing_offsets).ravel() # not centered
+    all_physicals = np.concatenate(nrecording_physicals).ravel() # not centered
+
+    # Flatten all chirps around events
+    all_onset_chirps = np.concatenate(nrecording_centered_onset_chirps).ravel()   # centered
+    all_offset_chirps = np.concatenate(nrecording_centered_offset_chirps).ravel() # centered
+    all_physical_chirps = np.concatenate(nrecording_centered_physical_chirps).ravel() # centered
+
+    # Convolute all chirps
+    # Divide by total number of each event over all recordings
+    all_onset_chirps_convolved = (acausal_kde1d(all_onset_chirps, time, width)) / len(all_onsets)
+    all_offset_chirps_convolved = (acausal_kde1d(all_offset_chirps, time, width)) / len(all_offsets)
+    all_physical_chirps_convolved = (acausal_kde1d(all_physical_chirps, time, width)) / len(all_physicals)
+
+
+    # Plot all events with all shuffled
+    fig, ax = plt.subplots(1, 3, figsize=(28*ps.cm, 16*ps.cm, ), constrained_layout=True, sharey='all')
+    # offsets = np.arange(1,28,1)
+    ax[0].set_xlabel('Time[s]')
+
+    # Plot chasing onsets
+    ax[0].set_ylabel('Chirp rate [Hz]')
+    ax[0].plot(time, all_onset_chirps_convolved, color=ps.yellow, zorder=2)
+    ax0 = ax[0].twinx()
+    nrecording_centered_onset_chirps = np.asarray(nrecording_centered_onset_chirps, dtype=object)
+    ax0.eventplot(np.array(nrecording_centered_onset_chirps), linelengths=0.5, colors=ps.gray, alpha=0.25, zorder=1)
+    ax0.vlines(0, 0, 1.5, ps.white, 'dashed')
+    ax[0].set_zorder(ax0.get_zorder()+1)
+    ax[0].patch.set_visible(False)
+    ax0.set_yticklabels([])
+    ax0.set_yticks([])
+    ax[0].fill_between(time, shuffled_q5_onset, shuffled_q95_onset, color=ps.gray, alpha=0.5)
+    ax[0].plot(time, shuffled_median_onset, color=ps.black)
+
+    # Plot chasing offets
+    ax[1].set_xlabel('Time[s]')
+    ax[1].plot(time, all_offset_chirps_convolved, color=ps.orange, zorder=2)
+    ax1 = ax[1].twinx()
+    nrecording_centered_offset_chirps = np.asarray(nrecording_centered_offset_chirps, dtype=object)
+    ax1.eventplot(np.array(nrecording_centered_offset_chirps), linelengths=0.5, colors=ps.gray, alpha=0.25, zorder=1)
+    ax1.vlines(0, 0, 1.5, ps.white, 'dashed')
+    ax[1].set_zorder(ax1.get_zorder()+1)
+    ax[1].patch.set_visible(False)
+    ax1.set_yticklabels([])
+    ax1.set_yticks([])
+    ax[1].fill_between(time, shuffled_q5_offset, shuffled_q95_offset, color=ps.gray, alpha=0.5)
+    ax[1].plot(time, shuffled_median_offset, color=ps.black)
+
+    # Plot physical contacts
+    ax[2].set_xlabel('Time[s]')
+    ax[2].plot(time, all_physical_chirps_convolved, color=ps.maroon, zorder=2)
+    ax2 = ax[2].twinx()
+    nrecording_centered_physical_chirps = np.asarray(nrecording_centered_physical_chirps, dtype=object)
+    ax2.eventplot(np.array(nrecording_centered_physical_chirps), linelengths=0.5, colors=ps.gray, alpha=0.25, zorder=1)
+    ax2.vlines(0, 0, 1.5, ps.white, 'dashed')
+    ax[2].set_zorder(ax2.get_zorder()+1)
+    ax[2].patch.set_visible(False)
+    ax2.set_yticklabels([])
+    ax2.set_yticks([])
+    ax[2].fill_between(time, shuffled_q5_physical, shuffled_q95_physical, color=ps.gray, alpha=0.5)
+    ax[2].plot(time, shuffled_median_physical, ps.black)
+    fig.suptitle('All recordings')
+    plt.show()
+    # plt.close()
+
+    embed()
+    
+    # chasing_durations = []
+    # # Calculate chasing duration to evaluate a nice time window for kernel density estimation
+    # for onset, offset in zip(chasing_onsets, chasing_offsets):
+    #     duration = offset - onset
+    #     chasing_durations.append(duration)
+
+    # fig, ax = plt.subplots()
+    # ax.boxplot(chasing_durations)
+    # plt.show()
+    # plt.close()
+
+
+    # # Associate chirps to individual fish
+    # fish1 = chirps[chirps_fish_ids == fish_ids[0]]
+    # fish2 = chirps[chirps_fish_ids == fish_ids[1]]
+    # fish = [len(fish1), len(fish2)]
+
+    # Convolution over all recordings
+    # Rasterplot for each recording
+
+
+    # #### Chirps around events, winner VS loser, one recording ####
+    # # Load file with fish ids and winner/loser info
+    # meta = pd.read_csv('../data/mount_data/order_meta.csv')
+    # current_recording = meta[meta.index == 43]
+    # fish1 = current_recording['rec_id1'].values
+    # fish2 = current_recording['rec_id2'].values
+    # # Implement check if fish_ids from meta and chirp detection are the same???
+    # winner = current_recording['winner'].values
+    
+    # if winner == fish1:
+    #     loser = fish2
+    # elif winner == fish2:
+    #     loser = fish1
+
+    # winner_chirps = chirps[chirps_fish_ids == winner]
+    # loser_chirps = chirps[chirps_fish_ids == loser]
+
+    # # Event triggered winner chirps
+    # _, winner_centered_onset, winner_cc_onset = event_triggered_chirps(chasing_onsets, winner_chirps, time_before_event, time_after_event, dt, width)
+    # _, winner_centered_offset, winner_cc_offset = event_triggered_chirps(chasing_offsets, winner_chirps, time_before_event, time_after_event, dt, width)
+    # _, winner_centered_physical, winner_cc_physical = event_triggered_chirps(physical_contacts, winner_chirps, time_before_event, time_after_event, dt, width)
+
+    # # Event triggered loser chirps
+    # _, loser_centered_onset, loser_cc_onset = event_triggered_chirps(chasing_onsets, loser_chirps, time_before_event, time_after_event, dt, width)
+    # _, loser_centered_offset, loser_cc_offset = event_triggered_chirps(chasing_offsets, loser_chirps, time_before_event, time_after_event, dt, width)
+    # _, loser_centered_physical, loser_cc_physical = event_triggered_chirps(physical_contacts, loser_chirps, time_before_event, time_after_event, dt, width)
+
+    # ########## Winner VS Loser plot ##########
+    # fig, ax = plt.subplots(2, 3, figsize=(50 / 2.54, 15 / 2.54), constrained_layout=True, sharey='row')
+    # offset = [1.35]
+    # ax[1][0].set_xlabel('Time[s]')
+    # ax[1][1].set_xlabel('Time[s]')
+    # ax[1][2].set_xlabel('Time[s]')
+    # # Plot winner chasing onsets
+    # ax[0][0].set_ylabel('Chirp rate [Hz]')
+    # ax[0][0].plot(time, winner_cc_onset, color='tab:blue', zorder=100)
+    # ax0 = ax[0][0].twinx()
+    # ax0.eventplot(np.array([winner_centered_onset]), lineoffsets=offset, linelengths=0.1, colors=['tab:green'], alpha=0.25, zorder=-100)
+    # ax0.set_ylabel('Event')
+    # ax0.vlines(0, 0, 1.5, 'tab:grey', 'dashed')
+    # ax[0][0].set_zorder(ax0.get_zorder()+1)
+    # ax[0][0].patch.set_visible(False)
+    # ax0.set_yticklabels([])
+    # ax0.set_yticks([])
+    # # Plot winner chasing offets
+    # ax[0][1].plot(time, winner_cc_offset, color='tab:blue', zorder=100)
+    # ax1 = ax[0][1].twinx()
+    # ax1.eventplot(np.array([winner_centered_offset]), lineoffsets=offset, linelengths=0.1, colors=['tab:purple'], alpha=0.25, zorder=-100)
+    # ax1.vlines(0, 0, 1.5, 'tab:grey', 'dashed')
+    # ax[0][1].set_zorder(ax1.get_zorder()+1)
+    # ax[0][1].patch.set_visible(False)
+    # ax1.set_yticklabels([])
+    # ax1.set_yticks([])
+    # # Plot winner physical contacts
+    # ax[0][2].plot(time, winner_cc_physical, color='tab:blue', zorder=100)
+    # ax2 = ax[0][2].twinx()
+    # ax2.eventplot(np.array([winner_centered_physical]), lineoffsets=offset, linelengths=0.1, colors=['tab:red'], alpha=0.25, zorder=-100)
+    # ax2.vlines(0, 0, 1.5, 'tab:grey', 'dashed')
+    # ax[0][2].set_zorder(ax2.get_zorder()+1)
+    # ax[0][2].patch.set_visible(False)
+    # ax2.set_yticklabels([])
+    # ax2.set_yticks([])
+    # # Plot loser chasing onsets
+    # ax[1][0].set_ylabel('Chirp rate [Hz]')
+    # ax[1][0].plot(time, loser_cc_onset, color='tab:blue', zorder=100)
+    # ax3 = ax[1][0].twinx()
+    # ax3.eventplot(np.array([loser_centered_onset]), lineoffsets=offset, linelengths=0.1, colors=['tab:green'], alpha=0.25, zorder=-100)
+    # ax3.vlines(0, 0, 1.5, 'tab:grey', 'dashed')
+    # ax[1][0].set_zorder(ax3.get_zorder()+1)
+    # ax[1][0].patch.set_visible(False)
+    # ax3.set_yticklabels([])
+    # ax3.set_yticks([])
+    # # Plot loser chasing offsets
+    # ax[1][1].plot(time, loser_cc_offset, color='tab:blue', zorder=100)
+    # ax4 = ax[1][1].twinx()
+    # ax4.eventplot(np.array([loser_centered_offset]), lineoffsets=offset, linelengths=0.1, colors=['tab:purple'], alpha=0.25, zorder=-100)
+    # ax4.vlines(0, 0, 1.5, 'tab:grey', 'dashed')
+    # ax[1][1].set_zorder(ax4.get_zorder()+1)
+    # ax[1][1].patch.set_visible(False)
+    # ax4.set_yticklabels([])
+    # ax4.set_yticks([])
+    # # Plot loser physical contacts
+    # ax[1][2].plot(time, loser_cc_physical, color='tab:blue', zorder=100)
+    # ax5 = ax[1][2].twinx()
+    # ax5.eventplot(np.array([loser_centered_physical]), lineoffsets=offset, linelengths=0.1, colors=['tab:red'], alpha=0.25, zorder=-100)
+    # ax5.vlines(0, 0, 1.5, 'tab:grey', 'dashed')
+    # ax[1][2].set_zorder(ax5.get_zorder()+1)
+    # ax[1][2].patch.set_visible(False)
+    # ax5.set_yticklabels([])
+    # ax5.set_yticks([])
+    # plt.show()
+    # plt.close()
+    
+
+    # for i in range(len(fish_ids)):
+    #     fish = fish_ids[i]
+    #     chirps_temp = chirps[chirps_fish_ids == fish]
+    #     print(fish)
+
+    #### Chirps around events, only losers, one recording ####
+
+
+
+if __name__ == '__main__':
+    # Path to the data
+    datapath = '../data/mount_data/'
+    main(datapath)

code/extract_chirps.py

@@ -4,6 +4,8 @@ import numpy as np
 from chirpdetection import chirpdetection
 from IPython import embed
 
+# check rec ../data/mount_data/2020-03-25-10_00/ starting at 3175
+
 
 def main(datapaths):
 
@@ -43,6 +45,7 @@ if __name__ == '__main__':
 
     recs = pd.DataFrame(columns=['recording'], data=valid_datasets)
     recs.to_csv('../recs.csv', index=False)
+    datapaths = ['../data/mount_data/2020-03-25-10_00/']
     main(datapaths)
 
 # window 1524 + 244 in dataset index 4 is nice example

code/modules/filehandling.py

@@ -3,6 +3,7 @@ import os
 import yaml
 import numpy as np
 from thunderfish.dataloader import DataLoader
+import matplotlib.pyplot as plt
 
 
 class ConfLoader:

code/modules/plotstyle.py

@@ -23,16 +23,16 @@ def PlotStyle() -> None:
         sky = "#89dceb"
         teal = "#94e2d5"
         green = "#a6e3a1"
-        yellow = "#f9e2af"
-        orange = "#fab387"
-        maroon = "#eba0ac"
-        red = "#f38ba8"
-        purple = "#cba6f7"
-        pink = "#f5c2e7"
+        yellow = "#f9d67f"
+        orange = "#faa472"
+        maroon = "#eb8486"
+        red = "#f37588"
+        purple = "#d89bf7"
+        pink = "#f59edb"
         lavender = "#b4befe"
-        gblue1 = "#8cb8ff"
-        gblue2 = "#7cdcdc"
-        gblue3 = "#82e896"
+        gblue1 = "#89b4fa"
+        gblue2 = "#89dceb"
+        gblue3 = "#a6e3a1"
 
         @classmethod
         def lims(cls, track1, track2):
@@ -229,7 +229,7 @@ def PlotStyle() -> None:
     plt.rc("legend", fontsize=SMALL_SIZE)  # legend fontsize
     plt.rc("figure", titlesize=BIGGER_SIZE)  # fontsize of the figure title
 
-    plt.rcParams["image.cmap"] = 'cmo.haline'
+    plt.rcParams["image.cmap"] = "cmo.haline"
     plt.rcParams["axes.xmargin"] = 0.05
     plt.rcParams["axes.ymargin"] = 0.1
     plt.rcParams["axes.titlelocation"] = "left"
@@ -261,31 +261,33 @@ def PlotStyle() -> None:
     # plt.rcParams["axes.grid"] = True    # display grid or not
     # plt.rcParams["axes.grid.axis"] = "y"  # which axis the grid is applied to
     plt.rcParams["axes.labelcolor"] = white
-    plt.rcParams["axes.axisbelow"] = True    # draw axis gridlines and ticks:
+    plt.rcParams["axes.axisbelow"] = True  # draw axis gridlines and ticks:
     plt.rcParams["axes.spines.left"] = True  # display axis spines
     plt.rcParams["axes.spines.bottom"] = True
     plt.rcParams["axes.spines.top"] = False
     plt.rcParams["axes.spines.right"] = False
     plt.rcParams["axes.prop_cycle"] = cycler(
-        'color', [
-            '#b4befe',
-            '#89b4fa',
-            '#74c7ec',
-            '#89dceb',
-            '#94e2d5',
-            '#a6e3a1',
-            '#f9e2af',
-            '#fab387',
-            '#eba0ac',
-            '#f38ba8',
-            '#cba6f7',
-            '#f5c2e7',
-        ])
+        "color",
+        [
+            "#b4befe",
+            "#89b4fa",
+            "#74c7ec",
+            "#89dceb",
+            "#94e2d5",
+            "#a6e3a1",
+            "#f9e2af",
+            "#fab387",
+            "#eba0ac",
+            "#f38ba8",
+            "#cba6f7",
+            "#f5c2e7",
+        ],
+    )
     plt.rcParams["xtick.color"] = gray  # color of the ticks
     plt.rcParams["ytick.color"] = gray  # color of the ticks
     plt.rcParams["grid.color"] = dark_gray  # grid color
-    plt.rcParams["figure.facecolor"] = black    # figure face color
-    plt.rcParams["figure.edgecolor"] = black   # figure edge color
+    plt.rcParams["figure.facecolor"] = black  # figure face color
+    plt.rcParams["figure.edgecolor"] = black  # figure edge color
     plt.rcParams["savefig.facecolor"] = black  # figure face color when saving
 
     return style
@@ -295,12 +297,11 @@ if __name__ == "__main__":
 
     s = PlotStyle()
 
-    import matplotlib.pyplot as plt
+    import matplotlib.cbook as cbook
     import matplotlib.cm as cm
     import matplotlib.pyplot as plt
-    import matplotlib.cbook as cbook
-    from matplotlib.path import Path
     from matplotlib.patches import PathPatch
+    from matplotlib.path import Path
 
     # Fixing random state for reproducibility
     np.random.seed(19680801)
@@ -308,14 +309,20 @@ if __name__ == "__main__":
     delta = 0.025
     x = y = np.arange(-3.0, 3.0, delta)
     X, Y = np.meshgrid(x, y)
-    Z1 = np.exp(-X**2 - Y**2)
-    Z2 = np.exp(-(X - 1)**2 - (Y - 1)**2)
+    Z1 = np.exp(-(X**2) - Y**2)
+    Z2 = np.exp(-((X - 1) ** 2) - (Y - 1) ** 2)
     Z = (Z1 - Z2) * 2
 
     fig1, ax = plt.subplots()
-    im = ax.imshow(Z, interpolation='bilinear', cmap=cm.RdYlGn,
-                   origin='lower', extent=[-3, 3, -3, 3],
-                   vmax=abs(Z).max(), vmin=-abs(Z).max())
+    im = ax.imshow(
+        Z,
+        interpolation="bilinear",
+        cmap=cm.RdYlGn,
+        origin="lower",
+        extent=[-3, 3, -3, 3],
+        vmax=abs(Z).max(),
+        vmin=-abs(Z).max(),
+    )
 
     plt.show()
 
@@ -328,22 +335,21 @@ if __name__ == "__main__":
     all_data = [np.random.normal(0, std, 100) for std in range(6, 10)]
 
     # plot violin plot
-    axs[0].violinplot(all_data,
-                      showmeans=False,
-                      showmedians=True)
-    axs[0].set_title('Violin plot')
+    axs[0].violinplot(all_data, showmeans=False, showmedians=True)
+    axs[0].set_title("Violin plot")
 
     # plot box plot
     axs[1].boxplot(all_data)
-    axs[1].set_title('Box plot')
+    axs[1].set_title("Box plot")
 
     # adding horizontal grid lines
     for ax in axs:
         ax.yaxis.grid(True)
-        ax.set_xticks([y + 1 for y in range(len(all_data))],
-                      labels=['x1', 'x2', 'x3', 'x4'])
-        ax.set_xlabel('Four separate samples')
-        ax.set_ylabel('Observed values')
+        ax.set_xticks(
+            [y + 1 for y in range(len(all_data))], labels=["x1", "x2", "x3", "x4"]
+        )
+        ax.set_xlabel("Four separate samples")
+        ax.set_ylabel("Observed values")
 
     plt.show()
 
@@ -355,24 +361,42 @@ if __name__ == "__main__":
     theta = np.linspace(0.0, 2 * np.pi, N, endpoint=False)
     radii = 10 * np.random.rand(N)
     width = np.pi / 4 * np.random.rand(N)
-    colors = cmo.cm.haline(radii / 10.)
+    colors = cmo.cm.haline(radii / 10.0)
 
-    ax = plt.subplot(projection='polar')
+    ax = plt.subplot(projection="polar")
     ax.bar(theta, radii, width=width, bottom=0.0, color=colors, alpha=0.5)
 
     plt.show()
 
-    methods = [None, 'none', 'nearest', 'bilinear', 'bicubic', 'spline16',
-               'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric',
-               'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos']
+    methods = [
+        None,
+        "none",
+        "nearest",
+        "bilinear",
+        "bicubic",
+        "spline16",
+        "spline36",
+        "hanning",
+        "hamming",
+        "hermite",
+        "kaiser",
+        "quadric",
+        "catrom",
+        "gaussian",
+        "bessel",
+        "mitchell",
+        "sinc",
+        "lanczos",
+    ]
 
     # Fixing random state for reproducibility
     np.random.seed(19680801)
 
     grid = np.random.rand(4, 4)
 
-    fig, axs = plt.subplots(nrows=3, ncols=6, figsize=(9, 6),
-                            subplot_kw={'xticks': [], 'yticks': []})
+    fig, axs = plt.subplots(
+        nrows=3, ncols=6, figsize=(9, 6), subplot_kw={"xticks": [], "yticks": []}
+    )
 
     for ax, interp_method in zip(axs.flat, methods):
         ax.imshow(grid, interpolation=interp_method)

code/plot_chirp_bodylegth.py

@@ -1,9 +1,9 @@
 import numpy as np
 
-import os 
+import os
 
 import numpy as np
-import matplotlib.pyplot as plt 
+import matplotlib.pyplot as plt
 from thunderfish.powerspectrum import decibel
 
 from IPython import embed
@@ -19,13 +19,22 @@ logger = makeLogger(__name__)
 
 def main(datapath: str):
 
-    foldernames = [datapath + x + '/'  for x in os.listdir(datapath) if os.path.isdir(datapath+x)]
-    path_to_csv = ('/').join(foldernames[0].split('/')[:-2]) + '/order_meta.csv'
-    meta_id = read_csv(path_to_csv)
-    meta_id['recording'] = meta_id['recording'].str[1:-1]
-    
+    foldernames = [
+        datapath + x + '/' for x in os.listdir(datapath) if os.path.isdir(datapath+x)]
+    path_order_meta  = (
+        '/').join(foldernames[0].split('/')[:-2]) + '/order_meta.csv'
+    order_meta_df = read_csv(path_order_meta)
+    order_meta_df['recording'] = order_meta_df['recording'].str[1:-1]
+    path_id_meta = (
+        '/').join(foldernames[0].split('/')[:-2]) + '/id_meta.csv'
+    id_meta_df = read_csv(path_id_meta)
+
     chirps_winner = []
+    size_diff = []
+    chirps_diff = []
     chirps_loser = []
+    freq_diff = []
+
 
     for foldername in foldernames:
         # behabvior is pandas dataframe with all the data
@@ -41,47 +50,111 @@ def main(datapath: str):
         category, timestamps = correct_chasing_events(category, timestamps)
 
         folder_name = foldername.split('/')[-2]
-        winner_row = meta_id[meta_id['recording'] == folder_name]
+        winner_row = order_meta_df[order_meta_df['recording'] == folder_name]
         winner = winner_row['winner'].values[0].astype(int)
         winner_fish1 = winner_row['fish1'].values[0].astype(int)
         winner_fish2 = winner_row['fish2'].values[0].astype(int)
+
+        groub = winner_row['group'].values[0].astype(int)
+        size_rows = id_meta_df[id_meta_df['group'] == groub]
+
+
         if winner == winner_fish1:
             winner_fish_id = winner_row['rec_id1'].values[0]
             loser_fish_id = winner_row['rec_id2'].values[0]
+
+            size_winners = []
+            for l in ['l1', 'l2', 'l3']:
+                size_winner = size_rows[size_rows['fish']== winner_fish1][l].values[0]
+                size_winners.append(size_winner)
+            mean_size_winner = np.nanmean(size_winners)
+
+
+            size_losers = []
+            for l in ['l1', 'l2', 'l3']:
+                size_loser = size_rows[size_rows['fish']== winner_fish2][l].values[0]
+                size_losers.append(size_loser)
+            mean_size_loser = np.nanmean(size_losers)
+
+            size_diff.append(mean_size_winner - mean_size_loser)
+
         elif winner == winner_fish2:
             winner_fish_id = winner_row['rec_id2'].values[0]
             loser_fish_id = winner_row['rec_id1'].values[0]
+
+            size_winners = []
+            for l in ['l1', 'l2', 'l3']:
+                size_winner = size_rows[size_rows['fish']== winner_fish2][l].values[0]
+                size_winners.append(size_winner)
+            mean_size_winner = np.nanmean(size_winners)
+
+            size_losers = []
+            for l in ['l1', 'l2', 'l3']:
+                size_loser = size_rows[size_rows['fish']== winner_fish1][l].values[0]
+                size_losers.append(size_loser)
+            mean_size_loser = np.nanmean(size_losers)
+
+            size_diff.append(mean_size_winner - mean_size_loser)
         else:
             continue
 
         print(foldername)
         all_fish_ids = np.unique(bh.chirps_ids)
-        chirp_loser = len(bh.chirps[bh.chirps_ids == loser_fish_id])
         chirp_winner = len(bh.chirps[bh.chirps_ids == winner_fish_id])
+        chirp_loser = len(bh.chirps[bh.chirps_ids == loser_fish_id])
+
+        freq_winner  = np.nanmedian(bh.freq[bh.ident==winner_fish_id])
+        freq_loser  = np.nanmedian(bh.freq[bh.ident==loser_fish_id])
+        
+        
         chirps_winner.append(chirp_winner)
         chirps_loser.append(chirp_loser)
 
+        chirps_diff.append(chirp_winner - chirp_loser)
+        freq_diff.append(freq_winner - freq_loser)
 
         fish1_id = all_fish_ids[0]
         fish2_id = all_fish_ids[1]
         print(winner_fish_id)
         print(all_fish_ids)
 
+    fig, (ax1, ax2, ax3) = plt.subplots(1,3, figsize=(10,5))
+    scatterwinner = 1.15
+    scatterloser = 1.85
+    bplot1 = ax1.boxplot(chirps_winner, positions=[
+                        1], showfliers=False, patch_artist=True)
+    bplot2 = ax1.boxplot(chirps_loser,  positions=[
+                        2], showfliers=False, patch_artist=True)
+    ax1.scatter(np.ones(len(chirps_winner))*scatterwinner, chirps_winner, color='r')
+    ax1.scatter(np.ones(len(chirps_loser))*scatterloser, chirps_loser, color='r')
+    ax1.set_xticklabels(['winner', 'loser'])
+    ax1.text(0.9, 0.9, f'n = {len(chirps_winner)}', transform=ax1.transAxes, color= ps.white)
 
-    fig, ax = plt.subplots()
-    ax.boxplot([chirps_winner, chirps_loser], showfliers=False)
-    ax.scatter(np.ones(len(chirps_winner)), chirps_winner, color='r')
-    ax.scatter(np.ones(len(chirps_loser))*2, chirps_loser, color='r')
-    ax.set_xticklabels(['winner', 'loser'])
     for w, l in zip(chirps_winner, chirps_loser):
-        ax.plot([1,2], [w,l], color='r', alpha=0.5, linewidth=0.5)
+        ax1.plot([scatterwinner, scatterloser], [w, l], color='r', alpha=0.5, linewidth=0.5)
 
-    ax.set_ylabel('Chirpscounts [n]')
+    colors1 = ps.red
+    ps.set_boxplot_color(bplot1, colors1)
+    colors1 = ps.orange
+    ps.set_boxplot_color(bplot2, colors1)
+    ax1.set_ylabel('Chirpscounts [n]')
+
+    ax2.scatter(size_diff, chirps_diff, color='r')
+    ax2.set_xlabel('Size difference [mm]')
+    ax2.set_ylabel('Chirps difference [n]')
+
+    ax3.scatter(freq_diff, chirps_diff, color='r')
+    ax3.set_xlabel('Frequency difference [Hz]')
+    ax3.set_yticklabels([])
+    ax3.set
+
+    plt.savefig('../poster/figs/chirps_winner_loser.pdf')
     plt.show()
 
+
 if __name__ == '__main__':
 
     # Path to the data
     datapath = '../data/mount_data/'
-    
-    main(datapath)
+
+    main(datapath)

code/plot_event_timeline.py

@@ -87,7 +87,7 @@ def main(datapath: str):
 
 
 
-        ax[3].axvspan(0, 3, 0, 5, facecolor='grey', alpha=0.5)
+        ax[3].axvspan(3, 6, 0, 5, facecolor='grey', alpha=0.5)
         ax[3].set_xticks(np.arange(0, 6.1, 0.5))
 
         labelpad = 40
@@ -98,9 +98,9 @@ def main(datapath: str):
 
         ax[3].set_xlabel('Time [h]')
         ax[0].set_title(foldername.split('/')[-2])
-
+        # 2020-03-31-9_59
         plt.show()
-    embed()
+        embed()
 
     # plot chirps
 

code/plot_introduction_specs.py

@@ -41,9 +41,9 @@ def main():
     freqtime2, freq2 = instantaneous_frequency(
         filtered2, data.raw_rate, smoothing_window=3)
 
-    ax1.plot(freqtime1*timescaler, freq1, color=ps.gblue1,
+    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.gblue3,
+    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)

poster/main.tex

@@ -1,4 +1,4 @@
-\documentclass[25pt, a0paper, landscape, margin=0mm, innermargin=20mm,
+\documentclass[25pt, a0paper, portrait, margin=0mm, innermargin=20mm,
 blockverticalspace=2mm, colspace=20mm, subcolspace=0mm]{tikzposter} %Default values for poster format options.
 
 \input{packages}
@@ -7,113 +7,84 @@ blockverticalspace=2mm, colspace=20mm, subcolspace=0mm]{tikzposter} %Default val
 \begin{document}
 
 \renewcommand{\baselinestretch}{1}
-\title{\parbox{1900pt}{Pushing the limits of time-frequency uncertainty in the
-detection of transient communication signals in weakly electric fish}}
-\author{Sina Prause, Alexander Wendt, Patrick Weygoldt}
-\institute{Supervised by Till Raab \& Jan Benda, Neurothology Group,
-University of Tübingen}
+\title{\parbox{1500pt}{Detection of transient communication signals in weakly electric fish}}
+\author{Sina Prause, Alexander Wendt, and Patrick Weygoldt}
+\institute{Supervised by Till Raab \& Jan Benda, Neuroethology Lab, University of Tuebingen}
 \usetitlestyle[]{sampletitle}
 \maketitle
 \renewcommand{\baselinestretch}{1.4}
 
 \begin{columns}
-\column{0.5}
+\column{0.4}
 \myblock[TranspBlock]{Introduction}{
-    \begin{minipage}[t]{0.55\linewidth}
-        The time-frequency tradeoff makes reliable signal detecion and simultaneous
-        sender identification of freely interacting individuals impossible.
-        This profoundly limits our current understanding of chirps to experiments
-        with single - or physically separated - individuals.
-    \end{minipage} \hfill
-    \begin{minipage}[t]{0.40\linewidth}
-    \vspace{-1.5cm}
+    The time-frequency tradeoff makes reliable signal detecion and simultaneous
+    sender identification of freely interacting individuals impossible.
+    This profoundly limits our current understanding of chirps to experiments
+    with single - or physically separated - individuals.
+    % \begin{tikzfigure}[]
+    %     \label{griddrawing}
+    %     \includegraphics[width=1\linewidth]{figs/introplot}
+    % \end{tikzfigure}
+}
+\myblock[TranspBlock]{Chirp detection}{
     \begin{tikzfigure}[]
-        \label{tradeoff}
-        \includegraphics[width=\linewidth]{figs/introplot}
+        \label{fig:example_a}
+        \includegraphics[width=1\linewidth]{figs/algorithm}
     \end{tikzfigure}
-    \end{minipage}
+    \vspace{0cm}
 }
 
-\myblock[TranspBlock]{A chirp detection algorithm}{
-        \begin{tikzfigure}[]
-            \label{modulations}
-            \includegraphics[width=\linewidth]{figs/algorithm}
-        \end{tikzfigure}
+\column{0.6}
+\myblock[TranspBlock]{Chirps during competition}{
+    \begin{tikzfigure}[]
+        \label{fig:example_b}
+        \includegraphics[width=0.5\linewidth]{example-image-b}
+    \end{tikzfigure}
+    \noindent
 }
 
-\column{0.5}
-\myblock[TranspBlock]{Chirps and diadic competitions}{
-    \begin{minipage}[t]{0.7\linewidth}
+\myblock[TranspBlock]{Interactions at modulations}{
+    \vspace{-1.2cm}
     \begin{tikzfigure}[]
-        \label{modulations}
-        \includegraphics[width=\linewidth]{figs/placeholder1}
+        \label{fig:example_c}
+        \includegraphics[width=0.5\linewidth]{example-image-c}
     \end{tikzfigure}
-    \end{minipage} \hfill
-    \begin{minipage}[t]{0.25\linewidth}
-        \lipsum[3][1-3]
-    \end{minipage}
-
-    \begin{minipage}[t]{0.7\linewidth}
-    \begin{tikzfigure}[]
-        \label{modulations}
-        \includegraphics[width=\linewidth]{figs/placeholder1}
-    \end{tikzfigure}
-    \end{minipage} \hfill
-    \begin{minipage}[t]{0.25\linewidth}
-        \lipsum[3][1-3]
-    \end{minipage}
-
-    \begin{minipage}[t]{0.7\linewidth}
-    \begin{tikzfigure}[]
-        \label{modulations}
-        \includegraphics[width=\linewidth]{figs/placeholder1}
-    \end{tikzfigure}
-    \end{minipage} \hfill
-    \begin{minipage}[t]{0.25\linewidth}
-        \lipsum[3][1-3]
-    \end{minipage}
-
 
+    \begin{multicols}{2}
+        \begin{itemize}
+            \setlength\itemsep{0.5em}
+            \item $\Delta$EOD$f$ does not appear to decrease during synchronous modulations ().
+            \item Individuals that rise their EOD$f$ first appear to rise their frequency higher compared to reactors (\textbf{B}).
+            \vfill
+            \null
+            \columnbreak
+            \item Synchronized fish keep distances below 1 m (\textbf{C}) but distances over 3 m also occur (see \textbf{movie}).
+            \item Spatial interactions increase \textbf{after} the start of a synchronous modulation (\textbf{D}).
+        \end{itemize}
+    \end{multicols}
+    \vspace{-1cm}
 }
 
-\myblock[TranspBlock]{Conclusion}{
-    \lipsum[3][1-9]
-}
+\myblock[GrayBlock]{Conclusion}{
+    \begin{itemize}
+        \setlength\itemsep{0.5em}
+        \item Our analysis is the first to indicate that \textit{A. leptorhynchus} uses long, diffuse and synchronized EOD$f$ signals to communicate in addition to chirps and rises.
+        \item The recorded fish do not exhibit jamming avoidance behavior while close during synchronous modulations.
+        \item Synchronous signals \textbf{initiate} spatio-temporal interactions.
+    \end{itemize}
+    \vspace{0.2cm}
+    }
+    \end{columns}
 
-% \column{0.3}
-% \myblock[TranspBlock]{More Results}{
-%     \begin{tikzfigure}[]
-%         \label{results}
-%         \includegraphics[width=\linewidth]{example-image-a}
-%     \end{tikzfigure}
-
-%     \begin{multicols}{2}
-%     \lipsum[5][1-8]
-%     \end{multicols}
-%     \vspace{-1cm}
-% }
-
-% \myblock[TranspBlock]{Conclusion}{
-%     \begin{itemize}
-%         \setlength\itemsep{0.5em}
-%         \item \lipsum[1][1]
-%         \item \lipsum[1][1]
-%         \item \lipsum[1][1]
-%     \end{itemize}
-%     \vspace{0.2cm}
-%     }
-\end{columns}
-
-\node[
-    above right,
+\node [above right,
     text=white,
     outer sep=45pt,
     minimum width=\paperwidth,
     align=center,
     draw,
     fill=boxes,
-    color=boxes,
-] at (-0.51\paperwidth,-43.5) {
-\textcolor{text}{\normalsize Contact: \{name\}.\{surname\}@student.uni-tuebingen.de}};
+    color=boxes] at (-43.6,-61) {
+        \textcolor{white}{
+    \normalsize Contact: \{name\}.\{surname\}@student.uni-tuebingen.de}};
 
 \end{document}

poster/packages.tex

@@ -1,11 +1,10 @@
 \usepackage[utf8]{inputenc}
 \usepackage[scaled]{helvet}
-\renewcommand\familydefault{\sfdefault}
+\renewcommand\familydefault{\sfdefault} 
 \usepackage[T1]{fontenc}
 \usepackage{wrapfig}
 \usepackage{setspace}
 \usepackage{multicol}
 \setlength{\columnsep}{1.5cm}
 \usepackage{xspace}
-\usepackage{tikz}
-\usepackage{lipsum}
+\usepackage{tikz}

poster/style.tex

@@ -16,10 +16,11 @@
 \colorlet{notefgcolor}{background}
 \colorlet{notebgcolor}{background}
 
+
 % Title setup
 \settitle{
 % Rearrange the order of the minipages to e.g. center the title between the logos
-\begin{minipage}[c]{0.6\paperwidth}
+\begin{minipage}[c]{0.8\paperwidth}
 %    \centering
     \vspace{2.5cm}\hspace{1.5cm}
     \color{text}{\Huge{\textbf{\@title}} \par}
@@ -30,26 +31,28 @@
     \vspace{2.5cm}
 \end{minipage}
 \begin{minipage}[c]{0.2\paperwidth}
-%    \centering
-    \vspace{1cm}\hspace{1cm}
-    \includegraphics[scale=1]{example-image-a}
-\end{minipage}
-\begin{minipage}[c]{0.2\paperwidth}
-%    \vspace{1cm}\hspace{1cm}
     \centering
-    \includegraphics[scale=1]{example-image-a}
+    % \vspace{1cm}
+    \hspace{-10cm}
+    \includegraphics[width=\linewidth]{example-image-a}
 \end{minipage}}
+% \begin{minipage}[c]{0.2\paperwidth}
+%     \vspace{1cm}\hspace{1cm}
+%     \centering
+%     \includegraphics[width=\linewidth]{example-image-a}
+% \end{minipage}}
 
-% definie title style with background box
+% define title style with background box (currently white)
 \definetitlestyle{sampletitle}{
-    width=1189mm,
+    width=841mm,
     roundedcorners=0,
     linewidth=0pt,
     innersep=15pt,
     titletotopverticalspace=0mm,
     titletoblockverticalspace=5pt
 }{
-    \begin{scope}[line width=\titlelinewidth, rounded corners=\titleroundedcorners]
+    \begin{scope}[line width=\titlelinewidth,
+        rounded corners=\titleroundedcorners]
     \draw[fill=text, color=boxes]
     (\titleposleft,\titleposbottom)
     rectangle

poster_old/main.tex

@@ -0,0 +1,119 @@
+\documentclass[25pt, a0paper, landscape, margin=0mm, innermargin=20mm,
+blockverticalspace=2mm, colspace=20mm, subcolspace=0mm]{tikzposter} %Default values for poster format options.
+
+\input{packages}
+\input{style}
+
+\begin{document}
+
+\renewcommand{\baselinestretch}{1}
+\title{\parbox{1900pt}{Pushing the limits of time-frequency uncertainty in the
+detection of transient communication signals in weakly electric fish}}
+\author{Sina Prause, Alexander Wendt, Patrick Weygoldt}
+\institute{Supervised by Till Raab \& Jan Benda, Neurothology Group,
+University of Tübingen}
+\usetitlestyle[]{sampletitle}
+\maketitle
+\renewcommand{\baselinestretch}{1.4}
+
+\begin{columns}
+\column{0.5}
+\myblock[TranspBlock]{Introduction}{
+    \begin{minipage}[t]{0.55\linewidth}
+        The time-frequency tradeoff makes reliable signal detecion and simultaneous
+        sender identification of freely interacting individuals impossible.
+        This profoundly limits our current understanding of chirps to experiments
+        with single - or physically separated - individuals.
+    \end{minipage} \hfill
+    \begin{minipage}[t]{0.40\linewidth}
+    \vspace{-1.5cm}
+    \begin{tikzfigure}[]
+        \label{tradeoff}
+        \includegraphics[width=\linewidth]{figs/introplot}
+    \end{tikzfigure}
+    \end{minipage}
+}
+
+\myblock[TranspBlock]{A chirp detection algorithm}{
+        \begin{tikzfigure}[]
+            \label{modulations}
+            \includegraphics[width=\linewidth]{figs/algorithm}
+        \end{tikzfigure}
+}
+
+\column{0.5}
+\myblock[TranspBlock]{Chirps and diadic competitions}{
+    \begin{minipage}[t]{0.7\linewidth}
+    \begin{tikzfigure}[]
+        \label{modulations}
+        \includegraphics[width=\linewidth]{figs/placeholder1}
+    \end{tikzfigure}
+    \end{minipage} \hfill
+    \begin{minipage}[t]{0.25\linewidth}
+        \lipsum[3][1-3]
+    \end{minipage}
+
+    \begin{minipage}[t]{0.7\linewidth}
+    \begin{tikzfigure}[]
+        \label{modulations}
+        \includegraphics[width=\linewidth]{figs/placeholder1}
+    \end{tikzfigure}
+    \end{minipage} \hfill
+    \begin{minipage}[t]{0.25\linewidth}
+        \lipsum[3][1-3]
+    \end{minipage}
+
+    \begin{minipage}[t]{0.7\linewidth}
+    \begin{tikzfigure}[]
+        \label{modulations}
+        \includegraphics[width=\linewidth]{figs/placeholder1}
+    \end{tikzfigure}
+    \end{minipage} \hfill
+    \begin{minipage}[t]{0.25\linewidth}
+        \lipsum[3][1-3]
+    \end{minipage}
+
+
+}
+
+\myblock[TranspBlock]{Conclusion}{
+    \lipsum[3][1-9]
+}
+
+% \column{0.3}
+% \myblock[TranspBlock]{More Results}{
+%     \begin{tikzfigure}[]
+%         \label{results}
+%         \includegraphics[width=\linewidth]{example-image-a}
+%     \end{tikzfigure}
+
+%     \begin{multicols}{2}
+%     \lipsum[5][1-8]
+%     \end{multicols}
+%     \vspace{-1cm}
+% }
+
+% \myblock[TranspBlock]{Conclusion}{
+%     \begin{itemize}
+%         \setlength\itemsep{0.5em}
+%         \item \lipsum[1][1]
+%         \item \lipsum[1][1]
+%         \item \lipsum[1][1]
+%     \end{itemize}
+%     \vspace{0.2cm}
+%     }
+\end{columns}
+
+\node[
+    above right,
+    text=white,
+    outer sep=45pt,
+    minimum width=\paperwidth,
+    align=center,
+    draw,
+    fill=boxes,
+    color=boxes,
+] at (-0.51\paperwidth,-43.5) {
+\textcolor{text}{\normalsize Contact: \{name\}.\{surname\}@student.uni-tuebingen.de}};
+
+\end{document}

poster_old/packages.tex

@@ -0,0 +1,11 @@
+\usepackage[utf8]{inputenc}
+\usepackage[scaled]{helvet}
+\renewcommand\familydefault{\sfdefault}
+\usepackage[T1]{fontenc}
+\usepackage{wrapfig}
+\usepackage{setspace}
+\usepackage{multicol}
+\setlength{\columnsep}{1.5cm}
+\usepackage{xspace}
+\usepackage{tikz}
+\usepackage{lipsum}

poster_old/style.tex

@@ -0,0 +1,119 @@
+\tikzposterlatexaffectionproofoff
+\usetheme{Default}
+
+\definecolor{text}{HTML}{e0e4f7}
+\definecolor{background}{HTML}{111116}
+\definecolor{boxes}{HTML}{2a2a32}
+\definecolor{unired}{HTML}{a51e37}
+
+\colorlet{blocktitlefgcolor}{text}
+\colorlet{backgroundcolor}{background}
+\colorlet{blocktitlebgcolor}{background}
+\colorlet{blockbodyfgcolor}{text}
+\colorlet{innerblocktitlebgcolor}{background}
+\colorlet{innerblocktitlefgcolor}{text}
+\colorlet{notefrcolor}{text}
+\colorlet{notefgcolor}{background}
+\colorlet{notebgcolor}{background}
+
+% Title setup
+\settitle{
+% Rearrange the order of the minipages to e.g. center the title between the logos
+\begin{minipage}[c]{0.6\paperwidth}
+%    \centering
+    \vspace{2.5cm}\hspace{1.5cm}
+    \color{text}{\Huge{\textbf{\@title}} \par}
+    \vspace*{2em}\hspace{1.5cm}
+    \color{text}{\LARGE \@author \par}
+    \vspace*{2em}\hspace{1.5cm}
+    \color{text}{\Large \@institute}
+    \vspace{2.5cm}
+\end{minipage}
+\begin{minipage}[c]{0.2\paperwidth}
+%    \centering
+    \vspace{1cm}\hspace{1cm}
+    \includegraphics[scale=1]{example-image-a}
+\end{minipage}
+\begin{minipage}[c]{0.2\paperwidth}
+%    \vspace{1cm}\hspace{1cm}
+    \centering
+    \includegraphics[scale=1]{example-image-a}
+\end{minipage}}
+
+% definie title style with background box
+\definetitlestyle{sampletitle}{
+    width=1189mm,
+    roundedcorners=0,
+    linewidth=0pt,
+    innersep=15pt,
+    titletotopverticalspace=0mm,
+    titletoblockverticalspace=5pt
+}{
+    \begin{scope}[line width=\titlelinewidth, rounded corners=\titleroundedcorners]
+    \draw[fill=text, color=boxes]
+    (\titleposleft,\titleposbottom)
+    rectangle
+    (\titleposright,\titlepostop);
+    \end{scope}
+}
+
+% define coustom block style for visible blocks
+\defineblockstyle{GrayBlock}{
+    titlewidthscale=1,
+    bodywidthscale=1,
+    % titlecenter,
+    titleleft,
+    titleoffsetx=0pt,
+    titleoffsety=-30pt,
+    bodyoffsetx=0pt,
+    bodyoffsety=-40pt,
+    bodyverticalshift=0mm,
+    roundedcorners=25,
+    linewidth=1pt,
+    titleinnersep=20pt,
+    bodyinnersep=38pt
+}{
+    \draw[rounded corners=\blockroundedcorners, inner sep=\blockbodyinnersep,
+          line width=\blocklinewidth, color=background,
+          top color=boxes, bottom color=boxes,
+          ]
+      (blockbody.south west) rectangle (blockbody.north east); %
+    \ifBlockHasTitle%
+        \draw[rounded corners=\blockroundedcorners, inner sep=\blocktitleinnersep,
+          top color=background, bottom color=background,
+          line width=2, color=background, %fill=blocktitlebgcolor
+          ]
+      (blocktitle.south west) rectangle (blocktitle.north east); %
+    \fi%
+}
+\newcommand\myblock[3][GrayBlock]{\useblockstyle{#1}\block{#2}{#3}\useblockstyle{Default}}
+
+% Define blockstyle for tranparent block
+\defineblockstyle{TranspBlock}{
+    titlewidthscale=0.99,
+    bodywidthscale=0.99,
+    titleleft,
+    titleoffsetx=15pt,
+    titleoffsety=-40pt,
+    bodyoffsetx=0pt,
+    bodyoffsety=-40pt,
+    bodyverticalshift=0mm,
+    roundedcorners=25,
+    linewidth=1pt,
+    titleinnersep=20pt,
+    bodyinnersep=38pt
+}{
+    \draw[rounded corners=\blockroundedcorners, inner sep=\blockbodyinnersep,
+          line width=\blocklinewidth, color=background,
+          top color=background, bottom color=background,
+          ]
+      (blockbody.south west) rectangle (blockbody.north east); %
+    \ifBlockHasTitle%
+        \draw[rounded corners=\blockroundedcorners, inner sep=\blocktitleinnersep,
+          top color=background, bottom color=background,
+          line width=2, color=background, %fill=blocktitlebgcolor
+          ]
+      (blocktitle.south west) rectangle (blocktitle.north east); %
+    \fi%
+}
+\renewcommand\myblock[3][TranspBlock]{\useblockstyle{#1}\block{#2}{#3}\useblockstyle{Default}}