#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import pandas as pd

pd.set_option('display.width', 2000)  # nezalamuj tabulky

from funkce.nacteni import *  # znaceni, channels, pocty_znacek, signal, sig_df_to_array
from funkce.vypocet import *
from pac_fac_all_frequency_bands import *
from sklearn import metrics

# --- výpis počtů značek věech subjektů
seegs = [15, 32, 45, 48]
# seegs = [15]
okoli = 150





#####výpočet main_df pro vykreslení signálů s ohledem na typ oscilace/resekci, zjistitelná i hodnota jednotlivých metod

def vypocet_metod_a_zapsani_signalu(seegs, okoli):
    """
    Version with signals for further examination

    Numerical representation of methods
    Parameters:
        seegs = [15, 32, 45, 48]
        okoli = 150
    -----------
    seegs - selected subjects
    Returns:
    --------
    main_df - dataframe with FR, vFR, uFR and PSE, PAC, FAC, SE
    Note: dříve zde byla chyba v indexování signálu pro výpočet uFR (opraveno 13/02/2019)

    Quick call: main_df_with_signal = vypocet_metod_a_vykresleni(seegs, okoli)
    """

    import pandas as pd
    import numpy as np
    pd.set_option('display.width', 2000)  # nezalamuj tabulky
    from funkce.nacteni import znaceni, info_o_patologii, channels, signal, sig_df_to_array
    from funkce.pocty_znacek import pocty_znacek
    from funkce.D_file_read import read_d_header
    from fnusa_sigproc.methods_uni import pse, pac, fac
    from pyentrp.entropy import shannon_entropy, sample_entropy
    import matplotlib.pyplot as plt
    from funkce.data_resampling import resample_signals

    # plt.close('all')

    # volba vzorkovací frekvence
    fs = 5000
    time = 2*(okoli/fs)


    # počáteční číslo figure - aby se grafy nepřekrývaly
    fig = 1

    # definice listu s výpočty všech seegs (nutné založení listu pro pozdějiší pd.concat)
    main_df_seegs_list = []


    for seeg in seegs:


        if okoli==60: # předpoklad pro výpočet metod z resamplovaných signálů
            #sig_FR_resampled, sig_vFR_resampled, sig_uFR_resampled = resample_signals()
            sig_FR, sig_vFR, sig_uFR = resample_signals(seeg)
            print('Počítám signály po resamplingu')

        else:
            # načtení signálů
            # získání dat signálu - # načtení offline - načtení z pickle/nový výpočet
            try:
                sig_FR = pd.read_pickle("Dataframes/sig_FR_n" + str(seeg) + "_okoli_" + str(2 * okoli) + ".pkl")
                sig_vFR = pd.read_pickle("Dataframes/sig_vFR_n" + str(seeg) + "_okoli_" + str(2 * okoli) + ".pkl")
                sig_uFR = pd.read_pickle("Dataframes/sig_uFR_n" + str(seeg) + "_okoli_" + str(2 * okoli) + ".pkl")
                print('sig_FR, sig_vFR, sig_uFR načteny ze souboru')
            except (OSError, IOError) as e:
                sig_FR, sig_vFR, sig_uFR = signal(seeg, okoli)
                print('počítám sig_FR, sig_vFR, sig_uFR')


        # načtení nebo výpočet dat
        try:
            main_df = pd.read_pickle("Dataframes/main_df_with_signals" + str(seeg)+ "_okoli_" + str(2*okoli) + ".pkl")
            print('main_df načtena ze souboru')

        except (OSError, IOError) as e:

            print('počítám main_df včetně signálů')
            # potřebuji kostru pro výpočet pse, entropie apod.
            nazev, FR, vFR, uFR, df_all_groups = znaceni(seeg)


            # potřebuji i informace o patologii pro přehlednější grafické znázornění
            nazev, FR, vFR, uFR, df_all_groups = info_o_patologii(seeg)


            ### Power spectral entropy - přidání do DF
            vFR['pse'] = 0  # pd.DataFrame(pse_vFR)  # ,'Column2':data[:,1]})
            uFR['pse'] = 0  # pd.DataFrame(pse_uFR)  # ,'Column2':data[:,1]})
            FR['pse'] = 0  # pd.DataFrame(pse_FR)  # ,'Column2':data[:,1]})

            ### Frequency-amplitude coupling
            FR['fac'] = 0
            vFR['fac'] = 0
            uFR['fac'] = 0

            ### Phase-amplitude coupling
            FR['pac'] = 0
            vFR['pac'] = 0
            uFR['pac'] = 0

            ### Shannon entropy
            FR['shannon_entropy'] = 0
            vFR['shannon_entropy'] = 0
            uFR['shannon_entropy'] = 0

            ### signál, ze kterého počítám
            FR['signal'] = 0
            vFR['signal'] = 0
            uFR['signal'] = 0

            FR['signal'] = FR['signal'].astype(object)
            vFR['signal'] = vFR['signal'].astype(object)
            uFR['signal'] = uFR['signal'].astype(object)


            # volba frekvencí pro výpočet fac a pac
            lfc1=1
            hfc1=30

            lfc2=65
            hfc2=180


            # výpočet
            for i in range(0, len(sig_FR.columns)):

                FR.set_value(i, 'signal', sig_FR[i])
                #plt.plot(range(0, len(FR.signal5[i])), FR.signal5[i])

                FR.pse.loc[i] = pse(sig_FR[i])
                FR.fac.loc[i] = fac(tuple(sig_FR[i]), fs, lfc1,hfc1,lfc2,hfc2)  #### opraveno: bere to po řádcích, ne po sloupcích
                FR.pac.loc[i] = pac(tuple(sig_FR[i]), fs, lfc1,hfc1,lfc2,hfc2)
                FR.shannon_entropy.loc[i] = shannon_entropy(tuple(sig_FR[i]))

            for i in range(0, len(sig_vFR.columns)):
                vFR.set_value(i, 'signal', sig_vFR[i])

                vFR.pse.loc[i] = pse(sig_vFR[i])
                vFR.fac.loc[i] = fac(tuple(sig_vFR[i]), fs, lfc1,hfc1,lfc2,hfc2)
                vFR.pac.loc[i] = pac(tuple(sig_vFR[i]), fs, lfc1,hfc1,lfc2,hfc2)
                vFR.shannon_entropy.loc[i] = shannon_entropy(tuple(sig_vFR[i]))

            for i in range(0, len(sig_uFR.columns)):
                uFR.set_value(i, 'signal', sig_uFR[i])

                uFR.pse.loc[i] = pse(sig_uFR[i])
                uFR.fac.loc[i] = fac(tuple(sig_uFR[i]), fs, lfc1,hfc1,lfc2,hfc2)
                uFR.pac.loc[i] = pac(tuple(sig_uFR[i]), fs, lfc1,hfc1,lfc2,hfc2)
                uFR.shannon_entropy.loc[i] = shannon_entropy(tuple(sig_uFR[i]))



            FR['sample_entropy0'] = ""  # FR_sample_entropy
            vFR['sample_entropy0'] = ""  # vFR_sample_entropy
            uFR['sample_entropy0'] = ""  # uFR_sample_entropy

            FR['sample_entropy1'] = ""
            vFR['sample_entropy1'] = ""
            uFR['sample_entropy1'] = ""

            for i in range(0, sig_FR.shape[1]):
                se = sample_entropy(sig_FR[i], 2)

                FR.sample_entropy0.loc[i] = se[0]
                FR.sample_entropy1.loc[i] = se[1]

            for i in range(0, sig_vFR.shape[1]):
                se = sample_entropy(sig_vFR[i], 2)

                vFR.sample_entropy0.loc[i] = se[0]
                vFR.sample_entropy1.loc[i] = se[1]

            for i in range(0, sig_uFR.shape[1]):
                se = sample_entropy(sig_uFR[i], 2)

                uFR.sample_entropy0.loc[i] = se[0]
                uFR.sample_entropy1.loc[i] = se[1]



            ### vykreslení
            import seaborn as sns

            sns.set(style="whitegrid")

            # pse_FR = sns.load_dataset("FR")
            FR['typ'] = 'FR'  # pd.DataFrame('FR',index=FR.index)
            vFR['typ'] = 'vFR'  # 'vFR'
            uFR['typ'] = 'uFR'  # 'uFR'


            main_df: pd.DataFrame = pd.concat([FR, vFR, uFR])
            main_df.reset_index(drop=True, inplace=True)


        try:
            print('Převádím sample_entropy do číselných hodnot')
            print(seeg)
            print(main_df)

            main_df.sample_entropy0 = main_df.sample_entropy0.astype(np.float64)
            main_df.sample_entropy1 = main_df.sample_entropy1.astype(np.float64)
        except (OSError, IOError) as e:
            print('Hodnoty již byly převedeny')

        main_df_with_signal = main_df

        main_df_with_signal.to_pickle("Dataframes/main_df_with_signals" + str(seeg)+ "_okoli_" + str(2*okoli) + ".pkl")

    return main_df_with_signal








def vykresleni_signalu_dle_targetu(seeg):
    """
    This function plots signal sections with regards to targets

    Parameters:
    -----------

    Returns:
    --------
    signal_df - dataframe of signals

    Quick_call: vykresleni_signalu_dle_targetu()
    """
    ## funkce pro vykreslení signálů


    import pandas as pd
    pd.set_option('display.width', 2000)  # nezalamuj tabulky
    from funkce.nacteni import signal
    import matplotlib.pyplot as plt


    seegs = [15, 32, 45, 48]
    okoli = 150


    #seeg = 45


    #for seeg in seegs:
    try:
        main_df_with_signal = pd.read_pickle("Dataframes/main_df_with_signals" + str(seeg)+ "_okoli_" + str(2*okoli) + ".pkl")
        print('načítám ze souboru')
    except (OSError, IOError) as e:
        main_df_with_signal = vypocet_metod_a_zapsani_signalu(seegs, okoli)
        print('musím si to propočítat, chvilku to zabere')




    #fvz = '5 kHz'
    seeg
    #vysledky_hodnot_pro_zvoleny_usek


    FR = main_df_with_signal[main_df_with_signal.typ == 'FR']
    vFR = main_df_with_signal[main_df_with_signal.typ == 'vFR']
    uFR = main_df_with_signal[main_df_with_signal.typ == 'uFR']

    FR_resected = main_df_with_signal[(main_df_with_signal['typ'] == 'FR') & (main_df_with_signal['resection'] == 'yes')] #včetně parametrů
    FR_non_resected = main_df_with_signal[(main_df_with_signal['typ'] == 'FR') & (main_df_with_signal['resection'] == 'no')] #včetně parametrů

    vFR_resected = main_df_with_signal[(main_df_with_signal['typ'] == 'vFR') & (main_df_with_signal['resection'] == 'yes')] #včetně parametrů
    vFR_non_resected = main_df_with_signal[(main_df_with_signal['typ'] == 'vFR') & (main_df_with_signal['resection'] == 'no')] #včetně parametrů

    uFR_resected = main_df_with_signal[(main_df_with_signal['typ'] == 'uFR') & (main_df_with_signal['resection'] == 'yes')] #včetně parametrů
    uFR_non_resected = main_df_with_signal[(main_df_with_signal['typ'] == 'uFR') & (main_df_with_signal['resection'] == 'no')] #včetně parametrů

    # resety indexů
    FR.reset_index(drop=True, inplace=True)
    vFR.reset_index(drop=True, inplace=True)
    uFR.reset_index(drop=True, inplace=True)

    FR_resected.reset_index(drop=True, inplace=True)
    FR_non_resected.reset_index(drop=True, inplace=True)
    vFR_resected.reset_index(drop=True, inplace=True)
    vFR_non_resected.reset_index(drop=True, inplace=True)
    uFR_resected.reset_index(drop=True, inplace=True)
    uFR_non_resected.reset_index(drop=True, inplace=True)

    import random
    import math
    import numpy as np


    #podle oscilace + resekované
    plt.figure(1, figsize=(15, 5))
    i = 0
    plt.suptitle('Úseky signálu pacienta ' + str(seeg))

    plt.subplot(1,3,1)
    for i in range(0,1):
        plt.plot(range(0, len(FR_resected.signal[i])), FR_resected.signal[i], color = 'r')
        plt.plot(range(0, len(FR_non_resected.signal[i])), FR_non_resected.signal[i], color = 'g')

    plt.title('Fast Ripples')
    plt.ylabel('amplituda signálu [μV]') #, fontsize=18)

    plt.subplot(1,3,2)
    for i in range(0,1):
        plt.plot(range(0, len(vFR_resected.signal[i])), vFR_resected.signal[i], color = 'r')
        plt.plot(range(0, len(vFR_non_resected.signal[i])), vFR_non_resected.signal[i], color = 'g')

    plt.title('very Fast Ripples')

    plt.subplot(1,3,3)
    for i in range(0,1):
        plt.plot(range(0, len(uFR_resected.signal[i])), uFR_resected.signal[i], color = 'r')
        plt.plot(range(0, len(uFR_non_resected.signal[i])), uFR_non_resected.signal[i], color = 'g')

    plt.title('ultra Fast Ripples')
    plt.subplots_adjust(top=0.85) #, bottom=0.1)

    plt.xlabel('vzorek signálu') #, fontsize=18)

    plt.savefig("Grafy/Signaly_v2__vsechny_typy_targetu_seeg_" + str(seeg)+ "_okoli_"+ str(okoli)+ ".png")


   # plt.close()

    #
#
    ##podle oscilace + neresekované
    #plt.figure(1, figsize=(15, 5))
    #i = 0
    #plt.suptitle('Úseky signálu pacienta ' + str(seeg))
#
    #plt.subplot(1,3,1)
    #for i in range(0,5):
    #    plt.plot(range(0, len(FR_non_resected.signal[i])), FR_non_resected.signal[i])
    #plt.title('Fast Ripples')
    #plt.ylabel('amplituda signálu [μV]') #, fontsize=18)
#
    #plt.subplot(1,3,2)
    #for i in range(0,5):
    #    plt.plot(range(0, len(vFR_non_resected.signal[i])), vFR_non_resected.signal[i])
    #plt.title('very Fast Ripples')
#
    #plt.subplot(1,3,3)
    #for i in range(0,1):
    #    plt.plot(range(0, len(uFR_non_resected.signal[i])), uFR_non_resected.signal[i])
    #plt.title('ultra Fast Ripples')
#
    #plt.xlabel('vzorek signálu') #, fontsize=18)




    #podle resekce

    # pozor, pouze ilustrativní - FR resekovaných a FR neresekovaných bývá např. u pacienta 45 a 48 málo -> velmi malý vzorek

    plt.figure(2, figsize=(10, 5))
    i = 0
    plt.suptitle('Úseky signálu pacienta ' + str(seeg))

    plt.subplot(1,2,1)
    for i in range(0,2):
        plt.plot(range(0, len(FR_resected.signal[i])), FR_resected.signal[i], color = 'gold', label = 'FR')
        plt.plot(range(0, len(vFR_resected.signal[i])), vFR_resected.signal[i], color = 'darkorange', label = 'vFR')
        plt.plot(range(0, len(uFR_resected.signal[i])), uFR_resected.signal[i], color = 'r', alpha = 0.9, label = 'uFR')

    plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.1), fancybox=True, shadow=True, ncol=2)
    plt.title('Resekované kanály')

    plt.tight_layout()
    plt.subplots_adjust(top=0.85) #, bottom=0.1)


    len(FR_non_resected)

    for i in range(0,2):
        plt.subplot(1,2,2)
        plt.plot(range(0, len(FR_non_resected.signal[i])), FR_non_resected.signal[i], color = 'greenyellow', label = 'FR')
        plt.plot(range(0, len(vFR_non_resected.signal[i])), vFR_non_resected.signal[i], color = 'limegreen', label = 'vFR')
        plt.plot(range(0, len(uFR_non_resected.signal[i])), uFR_non_resected.signal[i], color = 'g', alpha = 0.9, label = 'uFR')

    plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.1), fancybox=True, shadow=True, ncol=2)
    plt.title('Neresekované kanály')

    plt.tight_layout()
    plt.subplots_adjust(top=0.85) #, bottom=0.1)


    plt.savefig("Grafy/Signaly_v2_resekované_neresekované_seeg_" + str(seeg)+ "_okoli_"+ str(okoli)+ ".png")


    return FR_resected, vFR_resected, uFR_resected, FR_non_resected, vFR_non_resected, uFR_non_resected




def zkoumani_velikosti_hodnot_metody_jedineho_useku():
    """
    Parameters:
    -----------
    Returns:
    --------
    """
    ## funkce pro vykreslení signálů


    import pandas as pd
    pd.set_option('display.width', 2000)  # nezalamuj tabulky
    from funkce.nacteni import signal
    import matplotlib.pyplot as plt
    import numpy as np
    from scipy.signal import butter, hilbert, filtfilt
    import math

    seeg = 15
    FR_resected, vFR_resected, uFR_resected, FR_non_resected, vFR_non_resected, uFR_non_resected = vykresleni_signalu_dle_targetu(seeg)




    ### kód z methods_uni, PAC, zkoumání extrémních hodnot
    fs=5000
    lfc1=1
    hfc1=30
    lfc2=65
    hfc2=180

    import numpy as np
    from scipy.signal import butter, hilbert, filtfilt
    import math


    typy_oscilaci = ['Fast Ripple', 'very Fast Ripple', 'ultra Fast Ripple']


    if seeg == 45:
        met_title = 'Phase amplitude coupling'
        met ='pac'
        idxs = [11, 8] # pro FR, FAC: [8, 9]
        sigs = [FR_non_resected.signal[idxs[0]], uFR_resected.signal[idxs[1]]]

        typ_oscilace = ['Fast Ripple', 'ultra Fast Ripple']

    if seeg == 15:
        met_title = 'Frequency amplitude coupling'
        met ='fac'
        idxs = [42, 38] # NON - 42, 6, resekovaný - 55, 75, 26
        sigs = [FR_non_resected.signal[idxs[0]], FR_resected.signal[idxs[1]]]

        typ_oscilace = ['Fast Ripple, neresekovaný kanál', 'Fast Ripple, resekovaný kanál']



    i = 0
    for sig in sigs:
        #sig = FR_non_resected.signal[i]


        if met == 'pac':
            b,a = butter(2,[lfc1/(fs/2),hfc1/(fs/2)],'bandpass')
            sig_f = filtfilt(b,a,sig)
            sig_f_ph = np.angle(hilbert(sig_f))

            b,a = butter(2,[lfc2/(fs/2),hfc2/(fs/2)],'bandpass')
            sig_fh = filtfilt(b,a,sig)
            sig_a = abs(hilbert(sig_fh))**2

            pac = np.corrcoef(sig_f_ph,sig_a)[0][1] #Pearson product-moment correlation coefficients

            hodnota = pac

        elif met == 'fac':
            nsamp = len(sig)

            zpad = 2**(math.ceil(math.log(nsamp, 2)))
            sig_zeros = np.zeros(zpad)

            b,a = butter(2,[lfc1/(fs/2),hfc1/(fs/2)],'bandpass')
            sig_f = filtfilt(b,a,sig)

            b,a = butter(2,[lfc2/(fs/2),hfc2/(fs/2)],'bandpass')
            sig_fh = filtfilt(b,a,sig)
            sig_zeros[0:nsamp] = sig_fh

            sig_a = abs(hilbert(sig_zeros))**2
            sig_a = sig_a[0:nsamp]

            fac = np.corrcoef(sig_f,sig_a)[0][1]

            hodnota = fac

        #if seeg == 45:

            #idx_typ_signalu = [1, 3]

            #for i in idx_typ_signalu:

        plt.figure(i, figsize=(6,6))



        if met =='pac':

            plt.subplot(3,1,1)
            plt.plot(sig, color='black') # origo signál
            plt.title('Pacient ' +str(seeg)+ ', původní signál, ' + str(typ_oscilace[i]))


            plt.subplot(3,1,2)
            plt.plot(sig_f_ph) # pac 0,75
            plt.title('Fáze signálu')


            plt.subplot(3,1,3)
            plt.plot(sig_a, label = 'Hodnota pro metodu ' + str(met_title)+ ': ' + str(round(hodnota, 4))) #
            plt.title('Amplituda signálu')

            plt.tight_layout()
            plt.subplots_adjust(bottom=0.15)
            plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.25), shadow=True, ncol=1)


        elif met == 'fac':

            plt.subplot(3,1,1)
            plt.plot(sig, color='black') # origo signál
            plt.title('Pacient ' +str(seeg)+ ', původní signál, ' + str(typ_oscilace[i]))

            plt.subplot(3,1,2)
            plt.title('Frekvenční složka signálu')
            plt.plot(sig_f) # pac 0,75


            plt.subplot(3,1,3)
            plt.plot(sig_a, label = 'Hodnota pro metodu ' + str(met_title)+ ': ' + str(round(hodnota, 4))) #
            plt.title('Amplituda signálu')


            plt.tight_layout()
            plt.subplots_adjust(bottom=0.15)
            plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.25), shadow=True, ncol=1)



        plt.savefig("Grafy/Signaly_velikost_paramteru_"  + str(met)+ "_seeg_"+ str(seeg)+ "_okoli_"+ str(okoli)+ "_index_" +str(idxs[i])+ ".png")

        plt.show()

        i = i+1
    #plt.close()


    '''
    #### vykreslení individuálního signálu
    if seeg == 45:
        i = 7
        plt.subplot(1,2,1)
        plt.plot(range(0, len(vFR_resected.signal[i])), vFR_resected.signal[i], color = 'orange') # pac nějakých jen -0,72

        i = 28
        plt.subplot(1,2,2)
        plt.plot(range(0, len(vFR_resected.signal[i])), vFR_resected.signal[i], color = 'orange') # pac 0,75

        plt.show()

    '''






def vykresleni_signalu(typ_oscilace = 'sig_uFR', okoli = 300, r_count_input = 20, seegs = [15, 32, 45, 48]):
    """
    This function plots signal sections in all seegs, also returns signal_df

    Parameters:
    -----------

    Returns:
    --------
    signal_df - dataframe of signals

    Quick_call: signal_df = vykresleni_signalu()
    """
    ## funkce pro vykreslení signálů


    import pandas as pd
    pd.set_option('display.width', 2000)  # nezalamuj tabulky
    from funkce.nacteni import signal

    from pyentrp.entropy import shannon_entropy, sample_entropy


    # seegs = [15, 32, 45, 48]
    # okoli = 1250
    # okoli = 300
    # r_count_input = 20
    # typ_oscilace = 'sig_vFR'

    try:
        signals_df = pd.read_pickle("Dataframes/signals_df" + str(seegs) + "_okoli_" + str(2 * okoli) + ".pkl")
    except:
        signals_df = pd.DataFrame(columns=['Seeg', 'Okoli', 'sig_FR', 'sig_vFR', 'sig_uFR'])

        seeg_i = 0
        for seeg in seegs:
            sig_FR, sig_vFR, sig_uFR = signal(seeg, okoli)

            # uložení do df, ať nemusím spouštět stále znovu
            signals_df.loc[seeg_i]= [seeg, okoli, sig_FR, sig_vFR, sig_uFR]

            seeg_i = seeg_i+1

        signals_df.to_pickle("Dataframes/signals_df" + str(seegs) + "_okoli_" + str(2 * okoli) + ".pkl")




    import random
    import math
    import numpy as np

    r_count_max = math.inf
    r_c_info_seegs = []

    for ss in range(0,len(seegs)):
        r_c = signals_df.loc[ss, typ_oscilace].shape[1]
        r_c_info_seegs = np.append(r_c_info_seegs, r_c)
        if r_c < r_count_max: #zajištění, aby náhodný výběr nepřekročil počet značek napříč pacienty
            r_count_max = r_c

    if r_count_max<r_count_input:
        print('Napříč pacienty neexistuje tolik úznačených úseků, volím maximální možný počet: ' + str(r_count_max) + '')
        r_count = r_count_max
    else:
        r_count = r_count_input+1



    # --- vykresleni
    import matplotlib.pyplot as plt
    # seeg_i = range(0, len(seegs))
    sig_i = 0
    seeg_i = 0

    for seeg in seegs:

        r_range = []

        # výběr náhodných signálů v daném seeg a typu oscilace
        for i in range(0,r_count-1):
            x = random.randint(0,r_c_info_seegs[seeg_i]-1)#sig_uFR.shape[1]) r_c_info_seegs[seeg_i]
            if x not in r_range:
                r_range.append(x)

        r_range.sort()

        t= np.linspace(0,0.6, 2*okoli)

        plt.figure()
        for sig_i in r_range:
            # plt.subplot(511)
            plt.plot(t, signals_df.loc[seeg_i, typ_oscilace][sig_i])

            shannon_list = []
            shannon_e = shannon_entropy(tuple(signals_df.loc[seeg_i, typ_oscilace][sig_i]))
            shannon_list.append(shannon_e)


        shannon_mean=np.mean(shannon_list)
        print(shannon_mean)

        plt.ylim(-11000, 15000) # ,-11000)
        # plt.title('seeg: '+str(seeg)+', typ oscilace: ' +str(typ_oscilace)+ '')
        plt.title('seeg: ' + str(seeg) + ', typ oscilace: ' + str(typ_oscilace) + ', \n hodnota Shannonovy entropie: ' + str(round(shannon_mean, 3)))
        plt.xlabel('čas [s]')
        plt.ylabel('amplituda signálu [nV]')
        plt.tight_layout()



        # plt.plot((okoli, okoli), '+') # (-10000, 10000), 'k,-')
        plt.savefig("Grafy/Signaly_" + str(seeg) + "_typ_oscilace_" + str(typ_oscilace)+ "_okoli_"+ str(okoli)+ ".png")

        seeg_i = seeg_i+1

    plt.show()

    # signals_df.loc[0, 'sig_FR'] #super věc

    return signals_df






def shannon_entropy_pravdepodobnostni_funkce():
    """Return the Shannon Entropy of the sample data.

    Args:

    Returns:
        Funkce četností - pravděpodobnostní funkce
    """
    import matplotlib.pyplot as plt
    import numpy as np
    import seaborn as sns



    typ_oscilace = 'sig_uFR'
    typy_oscilaci = ['sig_FR', 'sig_vFR', 'sig_uFR']

    signals_df = vykresleni_signalu(typ_oscilace, okoli = 150, r_count_input = 20, seegs = [15, 32, 45, 48])

    plt.close('all')

    seegs = [15, 32, 45, 48]

    seeg = 45

    seeg_i = seegs.index(seeg) # seegs = [15, 32, 45, 48], seeg_i = [0, 1, 2, 3]


    for typ_osc in typy_oscilaci:

        plt.figure()
        for sig_i in range(0, signals_df.loc[seeg_i, typ_osc].shape[1]-1):

            # volba náhodného úseku z vykreslovaných signálů
            # import random
            # sig_i = random.randint(0, signals_df.loc[seeg_i, typ_oscilace].shape[1]-1)

            # výběr konkrétního úseku
            time_series = signals_df[typ_osc][seeg_i][sig_i] ## první


            # Check if string
            if not isinstance(time_series, str):
                time_series = list(time_series)

            # Create a frequency data
            data_set = list(set(time_series))
            freq_list = []
            for entry in data_set:
                counter = 0.
                for i in time_series:
                    if i == entry:
                        counter += 1
                freq_list.append(float(counter) / len(time_series))

            # sns.set();
            # sns.distplot(freq_list)
            plt.plot(range(len(freq_list)), freq_list)
            plt.title('Pravděpodobnostní funkce vybraných úseků signálu, pacient: '+str(seeg)+ 'typ oscilace: '+str(typ_osc)+'')

        plt.show()
        plt.savefig('Pravděpodobnostní funkce vybraných úseků signálu, pacient: '+str(seeg)+ 'typ oscilace: '+str(typ_osc)+".png")



     # entropie

    for typ_osc in typy_oscilaci:
        ee = []

        plt.figure()
        for sig_i in range(0, signals_df.loc[seeg_i, typ_osc].shape[1]-1):

            time_series = signals_df[typ_osc][seeg_i][sig_i] ## první

            # Check if string
            if not isinstance(time_series, str):
                time_series = list(time_series)

            # Create a frequency data
            data_set = list(set(time_series))
            freq_list = []
            for entry in data_set:
                counter = 0.
                for i in time_series:
                    if i == entry:
                        counter += 1
                freq_list.append(float(counter) / len(time_series))


            # Shannon entropy
            ent = 0.0
            ent_list = []
            for freq in freq_list:
                ent += freq * np.log2(freq)
                ent_list.append(ent)
            ent = -ent

            ee = np.append(ee, ent)
            plt.plot(ee)
            plt.title(''+str(seeg)+'_'+str(typ_osc)+'')

        plt.show()


    # return freq_list

