import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.signal import argrelextrema
# import seaborn as sns
import scipy
import statistics
import os
import timeit

from scipy import interpolate
from scipy import stats
# https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.find_peaks.html
# from scipy.signal import find_peaks

from scipy.signal import savgol_filter

def durationsizecross( df1):
    
    d= {'start green': [], 'end green': [],'min green':[],'mean green':[],'area green':[],'Duration green':[],'Size green':[],
       'start red': [], 'end red': [],'min red':[],'mean red':[],'area red':[],'Duration red':[],'Size red':[]}
    dfcross = pd.DataFrame(data=d)



    dfrr=[]
    rangelist=[]
    for i in range(0,len(df1)+1000,1000):
        rangelist.append(i)
    for num in range(len(rangelist)-1):

#         print(rangelist[num])

        dft=df1[rangelist[num]:rangelist[num+1]]
        dfgreen={}
        dfred={}
        dfcrossgr={}


        runnum=-1
        li=[]
        for i in range (1000):
            runnum=runnum+1
            li.append(runnum)

        dft=dft.copy()
        dft=dft.reset_index()
        

        y = dft['green']
        yred=dft['red']

        yhat = savgol_filter(y, 25, 3)
        yhatred = savgol_filter(yred, 25, 3)
        dft['zred']= yhatred
        meanred=dft['zred'].mean()
        stdred=dft['zred'].std()
        dft['stdred']=meanred+5*stdred
        dft['median red']=meanred

        dft['z']= yhat
        dft['time1']=li
        m=dft['z'].median()
        mean=dft['z'].mean()
        stdd=dft['z'].std()
        dft['median']=m
        dft['stdd']=mean-3*stdd
        dft['mean']=mean



        xx1 = dft['time1']
        f = dft['z']
        g = dft['mean']
        c=  dft['stdd']


        fred = dft['zred']
        gred = dft['median red']
        cred=  dft['stdred']
        idx1 = np.argwhere(np.diff(np.sign(f - c))).flatten()

        idx = np.argwhere(np.diff(np.sign(f - g))).flatten()

        idx1red = np.argwhere(np.diff(np.sign(fred - cred))).flatten()

        idxred = np.argwhere(np.diff(np.sign(fred - gred))).flatten()
    #     print(len(idx1))


        if len(idx1)>1:
            #######################33
            mscutstart=[]
            mscutend=[]
            minpointid=[]
            minpoint=[]
            if (len(idx1)% 2) == 0:
                for i in range(0,len(idx1)-1,2):
                    mscutstart.append(idx1[i])
                    mscutend.append(idx1[i+1])
                    minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmin()
                    minpo=dft['z'][idx1[i]:idx1[i+1]].min()
                    minpointid.append(minpoid)
                    minpoint.append(minpo)
            else:
                minpoid=dft['z'][idx1[0]:idx1[1]].idxmin()
                if minpoid>idx1[0]:
                    for i in range(0,len(idx1)-1,2):
                        mscutstart.append(idx1[i])
                        mscutend.append(idx1[i+1])
                        minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmin()
                        minpo=dft['z'][idx1[i]:idx1[i+1]].min()
                        minpointid.append(minpoid)
                        minpoint.append(minpo)
                else:
                    for i in range(1,len(idx1)-1,2):
                        mscutstart.append(idx1[i])
                        mscutend.append(idx1[i+1])
                        minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmin()
                        minpo=dft['z'][idx1[i]:idx1[i+1]].min()
                        minpointid.append(minpoid)
                        minpoint.append(minpo)

            medcutstart=[]
            medcutend=[]
            intarea=[]
            for i in range(len(mscutend)):
                if len(idx[idx<mscutstart[i]])==0:
                    s=0
                    e=0
                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=0
                    intarea.append(0)
                elif len(idx[idx>mscutend[i]])==0:
                    e=0
                    s=0
                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=0
                    intarea.append(0)
                else:
                    s=idx[idx<mscutstart[i]].max()

                    e=idx[idx>mscutend[i]].min()

                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=abs(sum(dft['z'][s:e]-mean))
                    intarea.append(ia)



                    #####################33



#             plt.plot(xx1, f, '-')
#             plt.plot(xx1, g, '-')

#             plt.plot(xx1, c, '-')

#             plt.plot(xx1[medcutstart], f[medcutstart], 'ro')
#             plt.plot(xx1[medcutend], f[medcutend], 'ro')


#             plt.plot(xx1[idx1], c[idx1], 'yo')
#             plt.plot(xx1[minpointid], f[minpointid], 'go')


#             plt.show()



            d = {'start green': medcutstart, 'end green': medcutend,'min green':minpoint,'mean green':mean,'area green':intarea}
            dfgreen = pd.DataFrame(data=d)
            dfgreen['Duration green']=dfgreen['end green']-dfgreen['start green']
            dfgreen['Size green']=abs(dfgreen['min green']-dfgreen['mean green']) 

    #####################################################3
        if len(idx1red)>1:
            #######################33
            mscutstartred=[]
            mscutendred=[]
            minpointidred=[]
            minpointred=[]
            if (len(idx1red)% 2) == 0:
                for i in range(0,len(idx1red)-1,2):
                    mscutstartred.append(idx1red[i])
                    mscutendred.append(idx1red[i+1])
                    minpoidred=dft['zred'][idx1red[i]:idx1red[i+1]].idxmax()
                    minpored=dft['zred'][idx1red[i]:idx1red[i+1]].max()
                    minpointidred.append(minpoidred)
                    minpointred.append(minpored)
            else:
                minpoidred=dft['zred'][idx1red[0]:idx1red[1]].idxmax()
                if minpoidred>idx1red[0]:
                    for i in range(0,len(idx1red)-1,2):
                        mscutstartred.append(idx1red[i])
                        mscutendred.append(idx1red[i+1])
                        minpoidred=dft['zred'][idx1red[i]:idx1red[i+1]].idxmax()
                        minpored=dft['zred'][idx1red[i]:idx1red[i+1]].max()
                        minpointidred.append(minpoidred)
                        minpointred.append(minpored)
                else:
                    for i in range(1,len(idx1red)-1,2):
                        mscutstartred.append(idx1red[i])
                        mscutendred.append(idx1red[i+1])
                        minpoidred=dft['z'][idx1red[i]:idx1red[i+1]].idxmax()
                        minpored=dft['z'][idx1red[i]:idx1red[i+1]].max()
                        minpointidred.append(minpoidred)
                        minpointred.append(minpored)

            medcutstartred=[]
            medcutendred=[]
            intareared=[]
            for i in range(len(mscutendred)):
                if len(idxred[idxred<mscutstartred[i]])==0:
                    s=0
                    e=0
                    medcutstartred.append(s)
                    medcutendred.append(e)
                    ia=0
                    intareared.append(0)
                elif len(idxred[idxred>mscutendred[i]])==0:
                    e=0
                    s=0
                    medcutstartred.append(s)
                    medcutendred.append(e)
                    ia=0
                    intareared.append(0)
                else:
                    s=idxred[idxred<mscutstartred[i]].max()

                    e=idxred[idxred>mscutendred[i]].min()

                    medcutstartred.append(s)
                    medcutendred.append(e)
                    ia=abs(sum(dft['z'][s:e]-meanred))
                    intareared.append(ia)



                    #####################33



#             plt.plot(xx1, fred, '-')
#             plt.plot(xx1, gred, '-')

#             plt.plot(xx1, cred, '-')

#             plt.plot(xx1[medcutstartred], fred[medcutstartred], 'ro')
#             plt.plot(xx1[medcutendred], fred[medcutendred], 'ro')


#             plt.plot(xx1[idx1red], cred[idx1red], 'yo')
#             plt.plot(xx1[minpointidred], fred[minpointidred], 'go')


#             plt.show()




            d = {'start red': medcutstartred, 'end red': medcutendred,'min red':minpointred,'mean red':meanred,'area red':intareared}
            dfred = pd.DataFrame(data=d)
            dfred['Duration red']=dfred['end red']-dfred['start red']
            dfred['Size red']=abs(dfred['min red']-dfred['mean red']) 



        crossind=[]
        bothgr=[]
        crossindred=[]
        if len(dfgreen)>0 and len(dfred)>0 :
            redlist=dfred.values.tolist()
            greenlist=dfgreen.values.tolist()


    #             print(len(redlist))
    #             print(len(greenlist))

            for i in range(len(greenlist)):
                for k in range(len(redlist)):


                    if greenlist[i][0]>redlist[k][0] and greenlist[i][0]<redlist[k][1]:
                        bothgr.append(greenlist[i]+redlist[k])

                        crossind.append(i)
                        crossindred.append(k)

                    elif greenlist[i][0]<redlist[k][0] and greenlist[i][1]>redlist[k][0]:
                        bothgr.append(greenlist[i]+redlist[k])

                        crossind.append(i)
                        crossindred.append(k)



#         print(crossind)
    #     print(len(crossind))
        if len(crossind)>0:
#             print(dfgreen.iloc[crossind])
            dfgreencroos=dfgreen.iloc[crossind]
#             print(crossind)
            dfredcroos=dfred.iloc[crossindred]
    
            dfgreencroos1=dfgreencroos.drop_duplicates(subset=['start green', 'end green'])
            dfredcroos1=dfredcroos.drop_duplicates(subset=['start red', 'end red'])
            dfbo=pd.DataFrame(bothgr, columns = ['start green', 'end green','min green','mean green','area green','Duration green','Size green',
       'start red', 'end red','min red','mean red','area red','Duration red','Size red'])
            dfbonodup=dfbo.drop_duplicates(subset=['start green', 'start red'])
#             dfgreencroos1=dfgreencroos1.reset_index()
#             dfredcroos1=dfredcroos1.reset_index()
    
#             print(dfgreencroos1)
#             print(dfredcroos1)
    


            frames = [dfgreencroos1, dfredcroos1]

            dfcrossgr = pd.concat(frames,axis=1)
            
            frames = [dfcross, dfbonodup]

            dfcross = pd.concat(frames)
            dfcross1=dfcross[dfcross['Duration green']<150]
            dfcross2=dfcross[dfcross['Duration red']<150]
#             print(dfcross)
            
#             print(dfcross)e

    return dfcross
def durationsizecrossforunevendata( df1):
    
    d= {'start green': [], 'end green': [],'min green':[],'mean green':[],'area green':[],'Duration green':[],'Size green':[],
       'start red': [], 'end red': [],'min red':[],'mean red':[],'area red':[],'Duration red':[],'Size red':[]}
    dfcross = pd.DataFrame(data=d)



    dfrr=[]
    rangelist=[]
    for i in range(0,len(df1)+1000,1000):
        rangelist.append(i)
    for num in range(len(rangelist)-2):

#         print(rangelist[num])

        dft=df1[rangelist[num]:rangelist[num+1]]
        dfgreen={}
        dfred={}
        dfcrossgr={}


        runnum=-1
        li=[]
        for i in range (1000):
            runnum=runnum+1
            li.append(runnum)

        dft=dft.copy()
        dft=dft.reset_index()

        y = dft['green']
        yred=dft['red']

        yhat = savgol_filter(y, 25, 3)
        yhatred = savgol_filter(yred, 25, 3)
        dft['zred']= yhatred
        meanred=dft['zred'].mean()
        stdred=dft['zred'].std()
        dft['stdred']=meanred+5*stdred
        dft['median red']=meanred

        dft['z']= yhat
        dft['time1']=li
        m=dft['z'].median()
        mean=dft['z'].mean()
        stdd=dft['z'].std()
        dft['median']=m
        dft['stdd']=mean-3*stdd
        dft['mean']=mean



        xx1 = dft['time1']
        f = dft['z']
        g = dft['mean']
        c=  dft['stdd']


        fred = dft['zred']
        gred = dft['median red']
        cred=  dft['stdred']
        idx1 = np.argwhere(np.diff(np.sign(f - c))).flatten()

        idx = np.argwhere(np.diff(np.sign(f - g))).flatten()

        idx1red = np.argwhere(np.diff(np.sign(fred - cred))).flatten()

        idxred = np.argwhere(np.diff(np.sign(fred - gred))).flatten()
    #     print(len(idx1))


        if len(idx1)>1:
            #######################33
            mscutstart=[]
            mscutend=[]
            minpointid=[]
            minpoint=[]
            if (len(idx1)% 2) == 0:
                for i in range(0,len(idx1)-1,2):
                    mscutstart.append(idx1[i])
                    mscutend.append(idx1[i+1])
                    minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmin()
                    minpo=dft['z'][idx1[i]:idx1[i+1]].min()
                    minpointid.append(minpoid)
                    minpoint.append(minpo)
            else:
                minpoid=dft['z'][idx1[0]:idx1[1]].idxmin()
                if minpoid>idx1[0]:
                    for i in range(0,len(idx1)-1,2):
                        mscutstart.append(idx1[i])
                        mscutend.append(idx1[i+1])
                        minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmin()
                        minpo=dft['z'][idx1[i]:idx1[i+1]].min()
                        minpointid.append(minpoid)
                        minpoint.append(minpo)
                else:
                    for i in range(1,len(idx1)-1,2):
                        mscutstart.append(idx1[i])
                        mscutend.append(idx1[i+1])
                        minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmin()
                        minpo=dft['z'][idx1[i]:idx1[i+1]].min()
                        minpointid.append(minpoid)
                        minpoint.append(minpo)

            medcutstart=[]
            medcutend=[]
            intarea=[]
            for i in range(len(mscutend)):
                if len(idx[idx<mscutstart[i]])==0:
                    s=0
                    e=0
                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=0
                    intarea.append(0)
                elif len(idx[idx>mscutend[i]])==0:
                    e=0
                    s=0
                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=0
                    intarea.append(0)
                else:
                    s=idx[idx<mscutstart[i]].max()

                    e=idx[idx>mscutend[i]].min()

                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=abs(sum(dft['z'][s:e]-mean))
                    intarea.append(ia)



                    #####################33



#             plt.plot(xx1, f, '-')
#             plt.plot(xx1, g, '-')

#             plt.plot(xx1, c, '-')

#             plt.plot(xx1[medcutstart], f[medcutstart], 'ro')
#             plt.plot(xx1[medcutend], f[medcutend], 'ro')


#             plt.plot(xx1[idx1], c[idx1], 'yo')
#             plt.plot(xx1[minpointid], f[minpointid], 'go')


#             plt.show()



            d = {'start green': medcutstart, 'end green': medcutend,'min green':minpoint,'mean green':mean,'area green':intarea}
            dfgreen = pd.DataFrame(data=d)
            dfgreen['Duration green']=dfgreen['end green']-dfgreen['start green']
            dfgreen['Size green']=abs(dfgreen['min green']-dfgreen['mean green']) 

    #####################################################3
        if len(idx1red)>1:
            #######################33
            mscutstartred=[]
            mscutendred=[]
            minpointidred=[]
            minpointred=[]
            if (len(idx1red)% 2) == 0:
                for i in range(0,len(idx1red)-1,2):
                    mscutstartred.append(idx1red[i])
                    mscutendred.append(idx1red[i+1])
                    minpoidred=dft['zred'][idx1red[i]:idx1red[i+1]].idxmax()
                    minpored=dft['zred'][idx1red[i]:idx1red[i+1]].max()
                    minpointidred.append(minpoidred)
                    minpointred.append(minpored)
            else:
                minpoidred=dft['zred'][idx1red[0]:idx1red[1]].idxmax()
                if minpoidred>idx1red[0]:
                    for i in range(0,len(idx1red)-1,2):
                        mscutstartred.append(idx1red[i])
                        mscutendred.append(idx1red[i+1])
                        minpoidred=dft['zred'][idx1red[i]:idx1red[i+1]].idxmax()
                        minpored=dft['zred'][idx1red[i]:idx1red[i+1]].max()
                        minpointidred.append(minpoidred)
                        minpointred.append(minpored)
                else:
                    for i in range(1,len(idx1red)-1,2):
                        mscutstartred.append(idx1red[i])
                        mscutendred.append(idx1red[i+1])
                        minpoidred=dft['zred'][idx1red[i]:idx1red[i+1]].idxmax()
                        minpored=dft['zred'][idx1red[i]:idx1red[i+1]].max()
                        minpointidred.append(minpoidred)
                        minpointred.append(minpored)

            medcutstartred=[]
            medcutendred=[]
            intareared=[]
            for i in range(len(mscutendred)):
                if len(idxred[idxred<mscutstartred[i]])==0:
                    s=0
                    e=0
                    medcutstartred.append(s)
                    medcutendred.append(e)
                    ia=0
                    intareared.append(0)
                elif len(idxred[idxred>mscutendred[i]])==0:
                    e=0
                    s=0
                    medcutstartred.append(s)
                    medcutendred.append(e)
                    ia=0
                    intareared.append(0)
                else:
                    s=idxred[idxred<mscutstartred[i]].max()

                    e=idxred[idxred>mscutendred[i]].min()

                    medcutstartred.append(s)
                    medcutendred.append(e)
                    ia=abs(sum(dft['z'][s:e]-meanred))
                    intareared.append(ia)



                    #####################33



#             plt.plot(xx1, fred, '-')
#             plt.plot(xx1, gred, '-')

#             plt.plot(xx1, cred, '-')

#             plt.plot(xx1[medcutstartred], fred[medcutstartred], 'ro')
#             plt.plot(xx1[medcutendred], fred[medcutendred], 'ro')


#             plt.plot(xx1[idx1red], cred[idx1red], 'yo')
#             plt.plot(xx1[minpointidred], fred[minpointidred], 'go')


#             plt.show()




            d = {'start red': medcutstartred, 'end red': medcutendred,'min red':minpointred,'mean red':meanred,'area red':intareared}
            dfred = pd.DataFrame(data=d)
            dfred['Duration red']=dfred['end red']-dfred['start red']
            dfred['Size red']=abs(dfred['min red']-dfred['mean red']) 



        crossind=[]
        bothgr=[]
        crossindred=[]
        if len(dfgreen)>0 and len(dfred)>0 :
            redlist=dfred.values.tolist()
            greenlist=dfgreen.values.tolist()


    #             print(len(redlist))
    #             print(len(greenlist))

            for i in range(len(greenlist)):
                for k in range(len(redlist)):


                    if greenlist[i][0]>redlist[k][0] and greenlist[i][0]<redlist[k][1]:
                        bothgr.append(greenlist[i]+redlist[k])

                        crossind.append(i)
                        crossindred.append(k)

                    elif greenlist[i][0]<redlist[k][0] and greenlist[i][1]>redlist[k][0]:
                        bothgr.append(greenlist[i]+redlist[k])

                        crossind.append(i)
                        crossindred.append(k)



#         print(crossind)
    #     print(len(crossind))
        if len(crossind)>0:
#             print(dfgreen.iloc[crossind])
            dfgreencroos=dfgreen.iloc[crossind]
#             print(crossind)
            dfredcroos=dfred.iloc[crossindred]
    
            dfgreencroos1=dfgreencroos.drop_duplicates(subset=['start green', 'end green'])
            dfredcroos1=dfredcroos.drop_duplicates(subset=['start red', 'end red'])
            dfbo=pd.DataFrame(bothgr, columns = ['start green', 'end green','min green','mean green','area green','Duration green','Size green',
       'start red', 'end red','min red','mean red','area red','Duration red','Size red'])
            dfbonodup=dfbo.drop_duplicates(subset=['start green', 'start red'])
#             dfgreencroos1=dfgreencroos1.reset_index()
#             dfredcroos1=dfredcroos1.reset_index()
    
#             print(dfgreencroos1)
#             print(dfredcroos1)
    


            frames = [dfgreencroos1, dfredcroos1]

            dfcrossgr = pd.concat(frames,axis=1)
            
            frames = [dfcross, dfbonodup]

            dfcross = pd.concat(frames)
            
#             print(dfcross)
            
#             print(dfcross)e

    return dfcross

def durationsize( df1):

    d= {'start': [], 'end': [],'min':[],'mean':[],'area':[]}
    dfall = pd.DataFrame(data=d)
    dfrr=[]
    rangelist=[]
    for i in range(0,len(df1)+1000,1000):
        rangelist.append(i)
    for num in range(len(rangelist)-1):

    #     print(rangelist[num])

        dft=df1[rangelist[num]:rangelist[num+1]]



        runnum=-1
        li=[]
        for i in range (1000):
            runnum=runnum+1
            li.append(runnum)

        dft=dft.copy()
        dft=dft.reset_index()

        y = dft['green']
        yhat = savgol_filter(y, 25, 3)
        dft['z']= yhat
        dft['time1']=li
        m=dft['z'].median()
        mean=dft['z'].mean()
        stdd=dft['z'].std()
        dft['median']=m
        dft['stdd']=mean-4*stdd
        dft['mean']=mean



        xx1 = dft['time1']
        f = dft['z']
        g = dft['mean']
        c=  dft['stdd']
        idx1 = np.argwhere(np.diff(np.sign(f - c))).flatten()

        idx = np.argwhere(np.diff(np.sign(f - g))).flatten()
    #     print(len(idx1))


        if len(idx1)>1:
            #######################33
            mscutstart=[]
            mscutend=[]
            minpointid=[]
            minpoint=[]
            if (len(idx1)% 2) == 0:
                for i in range(0,len(idx1)-1,2):
                    mscutstart.append(idx1[i])
                    mscutend.append(idx1[i+1])
                    minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmin()
                    minpo=dft['z'][idx1[i]:idx1[i+1]].min()
                    minpointid.append(minpoid)
                    minpoint.append(minpo)
            else:
                minpoid=dft['z'][idx1[0]:idx1[1]].idxmin()
                if minpoid>idx1[0]:
                    for i in range(0,len(idx1)-1,2):
                        mscutstart.append(idx1[i])
                        mscutend.append(idx1[i+1])
                        minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmin()
                        minpo=dft['z'][idx1[i]:idx1[i+1]].min()
                        minpointid.append(minpoid)
                        minpoint.append(minpo)
                else:
                    for i in range(1,len(idx1)-1,2):
                        mscutstart.append(idx1[i])
                        mscutend.append(idx1[i+1])
                        minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmin()
                        minpo=dft['z'][idx1[i]:idx1[i+1]].min()
                        minpointid.append(minpoid)
                        minpoint.append(minpo)

            medcutstart=[]
            medcutend=[]
            intarea=[]
            for i in range(len(mscutend)):
                if len(idx[idx<mscutstart[i]])==0:
                    s=0
                    e=0
                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=0
                    intarea.append(0)
                elif len(idx[idx>mscutend[i]])==0:
                    e=0
                    s=0
                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=0
                    intarea.append(0)
                else:
                    s=idx[idx<mscutstart[i]].max()

                    e=idx[idx>mscutend[i]].min()

                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=abs(sum(dft['z'][s:e]-mean))
                    intarea.append(ia)



                    #####################33



    #         plt.plot(x, f, '-')
    #         plt.plot(x, g, '-')

    #         plt.plot(x, c, '-')

    #         plt.plot(x[medcutstart], f[medcutstart], 'ro')
    #         plt.plot(x[medcutend], f[medcutend], 'ro')


    #         plt.plot(x[idx1], c[idx1], 'yo')
    #         plt.plot(x[minpointid], f[minpointid], 'go')
            # plt.plot(x[1577], f[1577], 'go')

    #         plt.show()



            d = {'start': medcutstart, 'end': medcutend,'min':minpoint,'mean':mean,'area':intarea}
            dfrr = pd.DataFrame(data=d)
            dfrr['Duration']=dfrr['end']-dfrr['start']
            dfrr['Size']=abs(dfrr['min']-dfrr['mean']) 

            frames = [dfall, dfrr]

            dfall = pd.concat(frames)
    dfsave = dfall[dfall['start'] != 0]
    dfsave1=dfsave.drop_duplicates(subset=['start', 'end'])
    return dfsave1


def durationsizered( df1):


    d= {'start': [], 'end': [],'min':[],'mean':[],'area':[]}
    dfall = pd.DataFrame(data=d)
    dfrr=[]
    rangelist=[]
    for i in range(0,len(df1)+1000,1000):
        rangelist.append(i)
    for num in range(len(rangelist)-1):

    #     print(rangelist[num])

        dft=df1[rangelist[num]:rangelist[num+1]]



        runnum=-1
        li=[]
        for i in range (1000):
            runnum=runnum+1
            li.append(runnum)

        dft=dft.copy()
        dft=dft.reset_index()

        y = dft['red']
        yhat = savgol_filter(y, 25, 3)
        dft['z']= yhat
        dft['time1']=li
        m=dft['z'].median()
        mean=dft['z'].mean()
        stdd=dft['z'].std()
        dft['median']=m
        dft['stdd']=mean+5*stdd
        dft['mean']=mean



        xx1 = dft['time1']
        f = dft['z']
        g = dft['mean']
        c=  dft['stdd']
        idx1 = np.argwhere(np.diff(np.sign(f - c))).flatten()

        idx = np.argwhere(np.diff(np.sign(f - g))).flatten()
    #     print(len(idx1))


        if len(idx1)>1:
            #######################33
            mscutstart=[]
            mscutend=[]
            minpointid=[]
            minpoint=[]
            if (len(idx1)% 2) == 0:
                for i in range(0,len(idx1)-1,2):
                    mscutstart.append(idx1[i])
                    mscutend.append(idx1[i+1])
                    minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmax()
                    minpo=dft['z'][idx1[i]:idx1[i+1]].max()
                    minpointid.append(minpoid)
                    minpoint.append(minpo)
            else:
                minpoid=dft['z'][idx1[0]:idx1[1]].idxmax()
                if minpoid>idx1[0]:
                    for i in range(0,len(idx1)-1,2):
                        mscutstart.append(idx1[i])
                        mscutend.append(idx1[i+1])
                        minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmax()
                        minpo=dft['z'][idx1[i]:idx1[i+1]].max()
                        minpointid.append(minpoid)
                        minpoint.append(minpo)
                else:
                    for i in range(1,len(idx1)-1,2):
                        mscutstart.append(idx1[i])
                        mscutend.append(idx1[i+1])
                        minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmax()
                        minpo=dft['z'][idx1[i]:idx1[i+1]].max()
                        minpointid.append(minpoid)
                        minpoint.append(minpo)

            medcutstart=[]
            medcutend=[]
            intarea=[]
            for i in range(len(mscutend)):
                if len(idx[idx<mscutstart[i]])==0:
                    s=0
                    e=0
                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=0
                    intarea.append(0)
                elif len(idx[idx>mscutend[i]])==0:
                    e=0
                    s=0
                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=0
                    intarea.append(0)
                else:
                    s=idx[idx<mscutstart[i]].max()

                    e=idx[idx>mscutend[i]].min()

                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=abs(sum(dft['z'][s:e]-mean))
                    intarea.append(ia)



                    #####################33



    #         plt.plot(x, f, '-')
    #         plt.plot(x, g, '-')

    #         plt.plot(x, c, '-')

    #         plt.plot(x[medcutstart], f[medcutstart], 'ro')
    #         plt.plot(x[medcutend], f[medcutend], 'ro')


    #         plt.plot(x[idx1], c[idx1], 'yo')
    #         plt.plot(x[minpointid], f[minpointid], 'go')
            # plt.plot(x[1577], f[1577], 'go')

    #         plt.show()



            d = {'start': medcutstart, 'end': medcutend,'min':minpoint,'mean':mean,'area':intarea}
            dfrr = pd.DataFrame(data=d)
            dfrr['Duration']=dfrr['end']-dfrr['start']
            dfrr['Size']=abs(dfrr['min']-dfrr['mean']) 

            frames = [dfall, dfrr]

            dfall = pd.concat(frames)
    dfsave = dfall[dfall['start'] != 0]
    dfsave1=dfsave.drop_duplicates(subset=['start', 'end'])
    return dfsave1

def durationsizecrossVirua( df1):
    
    d= {'start green': [], 'end green': [],'min green':[],'mean green':[],'area green':[],'Duration green':[],'Size green':[],
       'start red': [], 'end red': [],'min red':[],'mean red':[],'area red':[],'Duration red':[],'Size red':[]}
    dfcross = pd.DataFrame(data=d)



    dfrr=[]
    rangelist=[]
    for i in range(0,len(df1)+1000,1000):
        rangelist.append(i)
    for num in range(len(rangelist)-1):

#         print(rangelist[num])

        dft=df1[rangelist[num]:rangelist[num+1]]
        dfgreen={}
        dfred={}
        dfcrossgr={}


        runnum=-1
        li=[]
        for i in range (1000):
            runnum=runnum+1
            li.append(runnum)

        dft=dft.copy()
        dft=dft.reset_index()

        y = dft['green']
        yred=dft['red']

        yhat = savgol_filter(y, 25, 3)
        yhatred = savgol_filter(yred, 25, 3)
        dft['zred']= yhatred
        meanred=dft['zred'].mean()
        stdred=dft['zred'].std()
        dft['stdred']=meanred+5*stdred
        dft['median red']=meanred

        dft['z']= yhat
        dft['time1']=li
        m=dft['z'].median()
        mean=dft['z'].mean()
        stdd=dft['z'].std()
        dft['median']=m
        dft['stdd']=mean+3*stdd
        dft['mean']=mean



        xx1 = dft['time1']
        f = dft['z']
        g = dft['mean']
        c=  dft['stdd']


        fred = dft['zred']
        gred = dft['median red']
        cred=  dft['stdred']
        idx1 = np.argwhere(np.diff(np.sign(f - c))).flatten()

        idx = np.argwhere(np.diff(np.sign(f - g))).flatten()

        idx1red = np.argwhere(np.diff(np.sign(fred - cred))).flatten()

        idxred = np.argwhere(np.diff(np.sign(fred - gred))).flatten()
    #     print(len(idx1))


        if len(idx1)>1:
            #######################33
            mscutstart=[]
            mscutend=[]
            minpointid=[]
            minpoint=[]
            if (len(idx1)% 2) == 0:
                for i in range(0,len(idx1)-1,2):
                    mscutstart.append(idx1[i])
                    mscutend.append(idx1[i+1])
                    minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmax()
                    minpo=dft['z'][idx1[i]:idx1[i+1]].max()
                    minpointid.append(minpoid)
                    minpoint.append(minpo)
            else:
                minpoid=dft['z'][idx1[0]:idx1[1]].idxmax()
                if minpoid>idx1[0]:
                    for i in range(0,len(idx1)-1,2):
                        mscutstart.append(idx1[i])
                        mscutend.append(idx1[i+1])
                        minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmax()
                        minpo=dft['z'][idx1[i]:idx1[i+1]].max()
                        minpointid.append(minpoid)
                        minpoint.append(minpo)
                else:
                    for i in range(1,len(idx1)-1,2):
                        mscutstart.append(idx1[i])
                        mscutend.append(idx1[i+1])
                        minpoid=dft['z'][idx1[i]:idx1[i+1]].idxmax()
                        minpo=dft['z'][idx1[i]:idx1[i+1]].max()
                        minpointid.append(minpoid)
                        minpoint.append(minpo)

            medcutstart=[]
            medcutend=[]
            intarea=[]
            for i in range(len(mscutend)):
                if len(idx[idx<mscutstart[i]])==0:
                    s=0
                    e=0
                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=0
                    intarea.append(0)
                elif len(idx[idx>mscutend[i]])==0:
                    e=0
                    s=0
                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=0
                    intarea.append(0)
                else:
                    s=idx[idx<mscutstart[i]].max()

                    e=idx[idx>mscutend[i]].min()

                    medcutstart.append(s)
                    medcutend.append(e)
                    ia=abs(sum(dft['z'][s:e]-mean))
                    intarea.append(ia)



                    #####################33



#             plt.plot(xx1, f, '-')
#             plt.plot(xx1, g, '-')

#             plt.plot(xx1, c, '-')

#             plt.plot(xx1[medcutstart], f[medcutstart], 'ro')
#             plt.plot(xx1[medcutend], f[medcutend], 'ro')


#             plt.plot(xx1[idx1], c[idx1], 'yo')
#             plt.plot(xx1[minpointid], f[minpointid], 'go')


#             plt.show()



            d = {'start green': medcutstart, 'end green': medcutend,'min green':minpoint,'mean green':mean,'area green':intarea}
            dfgreen = pd.DataFrame(data=d)
            dfgreen['Duration green']=dfgreen['end green']-dfgreen['start green']
            dfgreen['Size green']=abs(dfgreen['min green']-dfgreen['mean green']) 

    #####################################################3
        if len(idx1red)>1:
            #######################33
            mscutstartred=[]
            mscutendred=[]
            minpointidred=[]
            minpointred=[]
            if (len(idx1red)% 2) == 0:
                for i in range(0,len(idx1red)-1,2):
                    mscutstartred.append(idx1red[i])
                    mscutendred.append(idx1red[i+1])
                    minpoidred=dft['zred'][idx1red[i]:idx1red[i+1]].idxmax()
                    minpored=dft['zred'][idx1red[i]:idx1red[i+1]].max()
                    minpointidred.append(minpoidred)
                    minpointred.append(minpored)
            else:
                minpoidred=dft['z'][idx1red[0]:idx1red[1]].idxmax()
                if minpoidred>idx1red[0]:
                    for i in range(0,len(idx1red)-1,2):
                        mscutstartred.append(idx1red[i])
                        mscutendred.append(idx1red[i+1])
                        minpoidred=dft['zred'][idx1red[i]:idx1red[i+1]].idxmax()
                        minpored=dft['zred'][idx1red[i]:idx1red[i+1]].max()
                        minpointidred.append(minpoidred)
                        minpointred.append(minpored)
                else:
                    for i in range(1,len(idx1red)-1,2):
                        mscutstartred.append(idx1red[i])
                        mscutendred.append(idx1red[i+1])
                        minpoidred=dft['zred'][idx1red[i]:idx1red[i+1]].idxmax()
                        minpored=dft['zred'][idx1red[i]:idx1red[i+1]].max()
                        minpointidred.append(minpoidred)
                        minpointred.append(minpored)

            medcutstartred=[]
            medcutendred=[]
            intareared=[]
            for i in range(len(mscutendred)):
                if len(idxred[idxred<mscutstartred[i]])==0:
                    s=0
                    e=0
                    medcutstartred.append(s)
                    medcutendred.append(e)
                    ia=0
                    intareared.append(0)
                elif len(idxred[idxred>mscutendred[i]])==0:
                    e=0
                    s=0
                    medcutstartred.append(s)
                    medcutendred.append(e)
                    ia=0
                    intareared.append(0)
                else:
                    s=idxred[idxred<mscutstartred[i]].max()

                    e=idxred[idxred>mscutendred[i]].min()

                    medcutstartred.append(s)
                    medcutendred.append(e)
                    ia=abs(sum(dft['z'][s:e]-meanred))
                    intareared.append(ia)



                    #####################33



#             plt.plot(xx1, fred, '-')
#             plt.plot(xx1, gred, '-')

#             plt.plot(xx1, cred, '-')

#             plt.plot(xx1[medcutstartred], fred[medcutstartred], 'ro')
#             plt.plot(xx1[medcutendred], fred[medcutendred], 'ro')


#             plt.plot(xx1[idx1red], cred[idx1red], 'yo')
#             plt.plot(xx1[minpointidred], fred[minpointidred], 'go')


#             plt.show()




            d = {'start red': medcutstartred, 'end red': medcutendred,'min red':minpointred,'mean red':meanred,'area red':intareared}
            dfred = pd.DataFrame(data=d)
            dfred['Duration red']=dfred['end red']-dfred['start red']
            dfred['Size red']=abs(dfred['min red']-dfred['mean red']) 


        bothgr=[]
        crossind=[]
        crossindred=[]
        if len(dfgreen)>0 and len(dfred)>0 :
            redlist=dfred.values.tolist()
            greenlist=dfgreen.values.tolist()


    #             print(len(redlist))
    #             print(len(greenlist))

            for i in range(len(greenlist)):
                for k in range(len(redlist)):


                    if greenlist[i][0]>redlist[k][0] and greenlist[i][0]<redlist[k][1]:
                        bothgr.append(greenlist[i]+redlist[k])

                        crossind.append(i)
                        crossindred.append(k)

                    elif greenlist[i][0]<redlist[k][0] and greenlist[i][1]>redlist[k][0]:
                        bothgr.append(greenlist[i]+redlist[k])

                        crossind.append(i)
                        crossindred.append(k)



#         print(crossind)
    #     print(len(crossind))
        if len(crossind)>0:
#             print(dfgreen.iloc[crossind])
            dfgreencroos=dfgreen.iloc[crossind]
#             print(crossind)
            dfredcroos=dfred.iloc[crossindred]
    
            dfgreencroos1=dfgreencroos.drop_duplicates(subset=['start green', 'end green'])
            dfredcroos1=dfredcroos.drop_duplicates(subset=['start red', 'end red'])
            dfbo=pd.DataFrame(bothgr, columns = ['start green', 'end green','min green','mean green','area green','Duration green','Size green',
       'start red', 'end red','min red','mean red','area red','Duration red','Size red'])
            dfbonodup=dfbo.drop_duplicates(subset=['start green', 'start red'])
#             dfgreencroos1=dfgreencroos1.reset_index()
#             dfredcroos1=dfredcroos1.reset_index()
    
#             print(dfgreencroos1)
#             print(dfredcroos1)
    


            frames = [dfgreencroos1, dfredcroos1]

            dfcrossgr = pd.concat(frames,axis=1)
            
            frames = [dfcross, dfbonodup]

            dfcross = pd.concat(frames)
#             print(dfcross)
            
#             print(dfcross)e

    return dfcross

# date inport
def dataex( fileloc):

    #change the file location
    filelocation=fileloc



    filelist=os.path.join(filelocation,"files.txt")
    my_file =open(filelist, "r")
    content_list = my_file.readlines()

    my_file.close()
    content_list=content_list[:-1]
    filename=[]
    for i in content_list:
        tttt=i[:-1]
        filename.append(tttt)
    return filename

def datacal( filelocation,fun):
#     filelocation=r"C:\Users\owner\Desktop\virometer data\1000"
    filename=dataex( filelocation)
    listname=[]
    for i in filename:
        listname.append([])

    for fn in range(len(filename)):
        data={}

    # for fn in range(1):

        #change the file location and file name
        df1 = pd.read_csv(os.path.join(filelocation,filename[fn]))
    #     print(filename[fn])
    #     print(len(df1))
        data=fun( df1)
        listname[fn]=data
    lenlist=[]

    for i in listname:
        lenlist.append(len(i))



    frames=[]
    for i in listname:
        frames.append(i)
    datafine = pd.concat(frames)
    return datafine,lenlist

def datacalfulmic( filelocation,fun):
#     filelocation=r"C:\Users\owner\Desktop\virometer data\1000"
    filename=dataex( filelocation)
    listname=[]
    for i in filename:
        listname.append([])

    for fn in range(len(filename)):
        data={}

    # for fn in range(1):

        #change the file location and file name
        df1 = pd.read_csv(os.path.join(filelocation,filename[fn]),names=["time",'green'])
    #     print(filename[fn])
    #     print(len(df1))
        data=fun( df1)
        listname[fn]=data
    lenlist=[]

    for i in listname:
        lenlist.append(len(i))



    frames=[]
    for i in listname:
        frames.append(i)
    datafine = pd.concat(frames)
    return datafine,lenlist