datasheet.R

# \\\
# Copyright 2021-2022 Louis Héraut*1
#
# *1   INRAE, France
#      louis.heraut@inrae.fr
#
# This file is part of ash R toolbox.
#
# ash R toolbox is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or (at
# your option) any later version.
#
# ash R toolbox is distributed in the hope that it will be useful, but 
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with ash R toolbox.  If not, see <https://www.gnu.org/licenses/>.
# ///
#
#
# plotting/datasheet.R
#
# Regroups all the graphical tools to generates the datasheets. More precisely, the 'datasheet_panel' function manages all the call for each station of the different graphical functions that generates info header, time serie visualisation and trend analysis graphs for every variable. It also deals with the arranging of all the plots in a single PDF page.


# Sourcing R file
source('processing/analyse.R', encoding='UTF-8') # hydrograph
source('plotting/shortcut.R', encoding='UTF-8')


## 1. DATASHEET PANEL ________________________________________________
# Manages datasheets creations for all stations. Makes the call to
# the different headers, trend analysis graphs and realises arranging
# every plots.
datasheet_panel = function (list_df2plot, df_meta, trend_period, info_header, time_header, foot_note, layout_matrix, info_ratio, time_ratio, var_ratio, foot_height, resources_path, logo_dir, AEAGlogo_file, INRAElogo_file, FRlogo_file, outdirTmp, df_page=NULL) {

    # The percentage of augmentation and diminution of the min
    # and max limits for y axis
    lim_pct = 10

    # Number of variable/plot
    nbp = length(list_df2plot)
    
    # Get all different stations code
    Code = levels(factor(df_meta$code))
    nCode = length(Code)

    # Convert 'trend_period' to list
    trend_period = as.list(trend_period)
    # Number of trend period
    nPeriod_trend = length(trend_period)

    # Extracts the min and the max of the mean trend for all the station
    res = short_trendExtremes(list_df2plot, Code, nPeriod_trend, nbp, nCode)
    minTrendValue = res$min
    maxTrendValue = res$max
    
    # Blank vector to store the max number of digit of label for
    # each station
    NspaceMax = c()
    # For all the station
    for (code in Code) {

        # Default max digit
        NspaceMax_code = 0

        # If the time header is given
        if (!is.null(time_header)) {
            nbpMod = nbp + 1
        }

        # For all type of graph
        for (i in 1:nbpMod) {

            if (i > nbp) {
                # Extracts the data serie corresponding to the code
                df_data_code = time_header[time_header$code == code,]
                type = 'sévérité'
            } else {
                # Extracts the data corresponding to the current variable
                df_data = list_df2plot[[i]]$data
                # Extracts the type corresponding to the current variable
                type = list_df2plot[[i]]$type
                # Extracts the data corresponding to the code
                df_data_code = df_data[df_data$code == code,]
            }

            # If variable type is date 
            if (type == 'saisonnalité') {
                # The number of digit is 6 because months are display
                # with 3 characters
                Nspace = 6
            # If it is a flow variable
            } else if (type == 'sévérité') {
                # Gets the max number of digit on the label
                maxtmp = max(df_data_code$Value, na.rm=TRUE)
                # Taking into account of the augmentation of
                # max for the window
                maxtmp = maxtmp * (1 + lim_pct/100)
                
                # If the max is greater than 10
                if (maxtmp >= 10) {
                    # The number of digit is the magnitude plus
                    # the first number times 2
                    Nspace = (get_power(maxtmp) + 1)*2
                    # Plus spaces between thousands hence every 8 digits
                    Nspace = Nspace + as.integer(Nspace/8)
                    # If the max is less than 10 and greater than 1
                } else if (maxtmp < 10 & maxtmp >= 1) {
                    # The number of digit is the magnitude plus
                    # the first number times 2 plus 1 for the dot
                    # and 2 for the first decimal
                    Nspace = (get_power(maxtmp) + 1)*2 + 3
                    # If the max is less than 1 (and obviously more than 0)
                } else if (maxtmp < 1) {
                    # Fixes the number of significant decimals to 3
                    maxtmp = signif(maxtmp, 3)
                    # The number of digit is the number of character
                    # of the max times 2 minus 1 for the dots that
                    # count just 1 space
                    Nspace = nchar(as.character(maxtmp))*2 - 1
                }
            }
            
            # If it is the temporary max number
            if (Nspace > NspaceMax_code) {
                # Stores it
                NspaceMax_code = Nspace
            }
        }
        # Stores the max digit number for labels of a station
        NspaceMax = c(NspaceMax, NspaceMax_code)
    }
    
    # For all the station
    for (k in 1:nCode) {
        # Gets the code
        code = Code[k]
        # Print code of the station for the current plotting
        print(paste("Datasheet for station : ", code,
                    "   (", round(k/nCode*100, 0), " %)", 
                    sep=''))
        
        # Number of header (is info and time serie are needed)
        nbh = as.numeric(info_header) + as.numeric(!is.null(time_header))
        # Actualises the number of plot
        nbg = nbp + nbh + as.numeric(foot_note)

        # Opens a blank list to store plot
        P = vector(mode='list', length=nbg)
        # If the info header is needed
        if (info_header) {            
            # Extracts the data serie corresponding to the code
            time_header_code = time_header[time_header$code == code,]
            # Gets the info plot
            Hinfo = info_panel(list_df2plot, 
                               df_meta,
                               trend_period=trend_period,
                               mean_period=mean_period,
                               periodHyd=mean_period[[1]],
                               df_shapefile=df_shapefile,
                               codeLight=code,
                               df_data_code=time_header_code)
            # Stores it
            P[[1]] = Hinfo
        }
        
        # If the time header is given
        if (!is.null(time_header)) {
            # Extracts the data serie corresponding to the code
            time_header_code = time_header[time_header$code == code,]
            # Gets the limits of the time serie
            axis_xlim = c(min(time_header_code$Date),
                          max(time_header_code$Date))
            # Gets the time serie plot
            Htime = time_panel(time_header_code, df_trend_code=NULL,
                               trend_period=trend_period, missRect=TRUE,
                               unit2day=365.25, var='Q', type='sévérité',
                               grid=TRUE, ymin_lim=0,
                               NspaceMax=NspaceMax[k],
                               first=TRUE, lim_pct=lim_pct)
            # Stores it
            P[[2]] = Htime
        }

        # Computes the number of column of plot asked on the datasheet
        nbcol = ncol(as.matrix(layout_matrix))
        # For all variable
        for (i in 1:nbp) {
            # Extracts the data corresponding to the current variable
            df_data = list_df2plot[[i]]$data
            # Extracts the trend corresponding to the
            # current variable
            df_trend = list_df2plot[[i]]$trend
            alpha = list_df2plot[[i]]$alpha
            unit2day = list_df2plot[[i]]$unit2day
            missRect = list_df2plot[[i]]$missRect
            # Extract the variable of the plot
            var = list_df2plot[[i]]$var
            type = list_df2plot[[i]]$type
            # Extracts the data corresponding to the code
            df_data_code = df_data[df_data$code == code,]
            # Extracts the trend corresponding to the code
            df_trend_code = df_trend[df_trend$code == code,]

            # Blank vector to store color
            color = c()
            
            # # Default grey color for not significant trend
            # grey = 85
            
            # For all the period
            for (j in 1:nPeriod_trend) {
                
                # If the trend is significant
                if (df_trend_code$p[j] <= alpha){
                    # Extract start and end of trend periods
                    Start = df_trend_code$period_start[j]
                    End = df_trend_code$period_end[j]

                    # Extracts the corresponding data for the period
                    df_data_code_per =
                        df_data_code[df_data_code$Date >= Start 
                                     & df_data_code$Date <= End,]
                    # Same for trend
                    df_trend_code_per = 
                        df_trend_code[df_trend_code$period_start == Start 
                                      & df_trend_code$period_end == End,]

                    # Computes the number of trend analysis selected
                    Ntrend = nrow(df_trend_code_per)
                    # If there is more than one trend on the same period
                    if (Ntrend > 1) {
                        # Takes only the first because they are similar
                        df_trend_code_per = df_trend_code_per[1,]
                    }

                    # If it is a flow variable
                    if (type == 'sévérité') {
                        # Computes the mean of the data on the period
                        dataMean = mean(df_data_code_per$Value,
                                        na.rm=TRUE)
                        # Normalises the trend value by the mean
                        # of the data
                        trendValue = df_trend_code_per$trend / dataMean
                    # If it is a date variable
                    } else if (type == 'saisonnalité') {
                        trendValue = df_trend_code_per$trend
                    }
                    
                    # Gets the color corresponding to the mean trend
                    color_res = get_color(trendValue, 
                                          minTrendValue[j, i],
                                          maxTrendValue[j, i],
                                          palette_name='perso',
                                          reverse=TRUE)
                    # Stores it temporarily
                    colortmp = color_res
                # Otherwise
                } else {
                    # Stores the default grey color
                    colortmp = paste('grey85', sep='')
                    
                }
                # Stores the color
                color = append(color, colortmp)                
            }

            # Computes the time panel associated to the current variable
            p = time_panel(df_data_code, df_trend_code, var=var,
                           type=type, alpha=alpha,
                           missRect=missRect, trend_period=trend_period,
                           mean_period=mean_period, axis_xlim=axis_xlim, 
                           unit2day=unit2day, grid=FALSE, color=color,
                           NspaceMax=NspaceMax[k], last=(i == nbp),
                           lim_pct=lim_pct)

            # Stores the plot
            P[[i+nbh]] = p            
        }

        if (!is.null(df_page)) {
            section = 'Fiche station'
            subsection = code
            n_page = df_page$n[nrow(df_page)] + 1
            df_page = bind_rows(
                df_page,
                tibble(section=section,
                       subsection=subsection,
                       n=n_page))
        }
        
        if (foot_note) {
            footName = 'fiche station'
            if (is.null(df_page)) {
                n_page = k
            }
            
            foot = foot_panel(footName, n_page, resources_path,
                              logo_dir,
                              AEAGlogo_file, INRAElogo_file,
                              FRlogo_file, foot_height)
            P[[nbg]] = foot
        }
        
        # Convert the 'layout_matrix' to a matrix if it is not already 
        layout_matrix = as.matrix(layout_matrix)

        # Number of element of the matrix
        nel = nrow(layout_matrix)*ncol(layout_matrix)
        # Gets the place where there is NA value
        idNA = which(is.na(layout_matrix), arr.ind=TRUE)

        LM = layout_matrix
        # Adds non existing plot is where the is NA
        LM[idNA] = seq(max(layout_matrix, na.rm=TRUE) + 1,
                       max(layout_matrix, na.rm=TRUE) + 1 +
                       nel)
        # Shifts all plots to be coherent with the adding of header
        LM = LM + nbh
        
        if (!is.null(time_header)) {
            LM = rbind(2, LM)
        } else {
            time_ratio = 0
        }
        if (info_header) {
            LM = rbind(1, LM)
        } else {
            info_ratio = 0
        }
        
        if (foot_note) {
            id_foot = length(LM) + 1
            LM = rbind(LM, id_foot)
        } else {
            foot_height = 0
        }

        LMcol = ncol(LM)
        LMrow = nrow(LM)
        
        LM = rbind(rep(99, times=LMcol), LM, rep(99, times=LMcol))
        LMrow = nrow(LM)
        LM = cbind(rep(99, times=LMrow), LM, rep(99, times=LMrow))
        LMcol = ncol(LM)
        
        margin_size = 0.5
        height = 29.7
        width = 21

        Norm_ratio = height * (info_ratio + time_ratio + var_ratio*nbp) / (height - 2*margin_size - foot_height)

        info_height = height * info_ratio / Norm_ratio
        time_height = height * time_ratio / Norm_ratio
        var_height = height * var_ratio / Norm_ratio

        Hcut = LM[, 2]
        heightLM = rep(0, times=LMrow) 
        
        heightLM[Hcut == 1] = info_height
        heightLM[Hcut == 2] = time_height
        heightLM[Hcut > 2 & Hcut < id_foot] = var_height
        heightLM[Hcut == id_foot] = foot_height
        heightLM[Hcut == 99] = margin_size

        col_width = (width - 2*margin_size) / (LMcol - 2)
        
        Wcut = LM[(nrow(LM)-1),]
        widthLM = rep(col_width, times=LMcol)
        widthLM[Wcut == 99] = margin_size

        # Plot the graph as the layout
        plot = grid.arrange(grobs=P, layout_matrix=LM,
                            heights=heightLM, widths=widthLM)

        # Saving
        ggsave(plot=plot, 
               path=outdirTmp,
               filename=paste(as.character(code), '.pdf', sep=''),
               width=width, height=height, units='cm', dpi=100)
        
    }
    return (df_page)
}


## 2. OTHER PANEL FOR THE DATASHEET __________________________________
### 2.1. Time panel __________________________________________________
time_panel = function (df_data_code, df_trend_code, var, type, alpha=0.1, missRect=FALSE, unit2day=365.25, trend_period=NULL, mean_period=NULL, axis_xlim=NULL, grid=TRUE, ymin_lim=NULL, color=NULL, NspaceMax=NULL, first=FALSE, last=FALSE, lim_pct=10) {

    # If 'type' is square root apply it to data
    if (var == 'sqrt(Q)') {
        df_data_code$Value = sqrt(df_data_code$Value)
    }
    
    # Compute max and min of flow
    maxQ = max(df_data_code$Value, na.rm=TRUE)
    minQ = min(df_data_code$Value, na.rm=TRUE)

    spread = maxQ - minQ
    
    nTick = 6
    maxQ_win = maxQ + spread*lim_pct/100
    minQ_win = minQ - spread*lim_pct/100

    if (minQ_win < 0) {
        minQtmp_lim = 0
    } else {
        minQtmp_lim = minQ_win
    }

    if (!is.null(ymin_lim)) {
        minQ_win = ymin_lim
    }
    
    spreadtmp = maxQ_win - minQtmp_lim
    
    breakQtmp = spreadtmp / (nTick - 1)

    GradQ_10 = c(0, 1, 1.5, 2, 2.5, 3, 4, 5, 10)

    Grad = GradQ_10 * 10^get_power(breakQtmp)
    dist = abs(Grad - breakQtmp)
    idGrad = which.min(dist)
    breakQ = Grad[idGrad]
    
    if (is.null(ymin_lim)) {
        Grad = GradQ_10 * 10^get_power(minQtmp_lim)      
        Grad[Grad > minQtmp_lim] = NA        
        dist = abs(Grad - minQtmp_lim)        
        idGrad = which.min(dist)        
        minQ_lim = Grad[idGrad]        
    } else {        
        minQ_lim = ymin_lim
    }
    maxQ_list = c()
    i = 1
    maxQtmp = minQ_lim
    
    while (maxQtmp <= maxQ_win) {
        maxQtmp = minQ_lim + i*breakQ
        i = i + 1
    }   
    maxQ_lim = maxQtmp    
    
    
    # If x axis limits are specified
    if (!is.null(axis_xlim)) {
        minor_minDatetmp_lim = as.Date(axis_xlim[1])
        minor_maxDatetmp_lim = as.Date(axis_xlim[2])
    # Otherwise
    } else {
        minor_minDatetmp_lim = as.Date(df_data_code$Date[1]) 
        minor_maxDatetmp_lim =
            as.Date(df_data_code$Date[length(df_data_code$Date)])
    }

    minor_minDatetmp_lim = as.numeric(format(minor_minDatetmp_lim, "%Y"))
    minor_maxDatetmp_lim = as.numeric(format(minor_maxDatetmp_lim, "%Y"))

    minDatetmp_lim = minor_minDatetmp_lim
    maxDatetmp_lim = minor_maxDatetmp_lim

    nTick = 8
    
    spreadtmp = minor_maxDatetmp_lim - minor_minDatetmp_lim
    breakDatetmp = spreadtmp / (nTick - 1)

    GradDate_10 = c(1, 2.5, 5, 10)

    Grad = GradDate_10 * 10^get_power(breakDatetmp)
    dist = abs(Grad - breakDatetmp)
    idGrad = which.min(dist)
    breakDate = Grad[idGrad]

    listDate = seq(round(minDatetmp_lim, -1)-10^(get_power(breakDate)+1),
                   round(maxDatetmp_lim, -1)+10^(get_power(breakDate)+1),
                   by=breakDate)

    minDate_lim = listDate[which.min(abs(listDate - minDatetmp_lim))]
    maxDate_lim = listDate[which.min(abs(listDate - maxDatetmp_lim))]
    minDate_lim = as.Date(paste(minDate_lim, '-01-01', sep=''))
    maxDate_lim = as.Date(paste(maxDate_lim, '-01-01', sep=''))


    minor_breakDatetmp = breakDate / 5
    
    GradMinorDate_10 = c(1, 2, 5, 10)

    Grad = GradMinorDate_10 * 10^get_power(minor_breakDatetmp)
    dist = abs(Grad - minor_breakDatetmp)
    idGrad = which.min(dist)
    minor_breakDate = Grad[idGrad]
    
    listDate = seq(round(minor_minDatetmp_lim,
                         -1) - 10^(get_power(minor_breakDate)+1),
                   round(minor_maxDatetmp_lim,
                         -1) + 10^(get_power(minor_breakDate)+1),
                   by=minor_breakDate)

    minor_minDate_lim =
        listDate[which.min(abs(listDate - minor_minDatetmp_lim))]
    minor_maxDate_lim =
        listDate[which.min(abs(listDate - minor_maxDatetmp_lim))]
    minor_minDate_lim = as.Date(paste(minor_minDate_lim,
                                      '-01-01', sep=''))
    minor_maxDate_lim = as.Date(paste(minor_maxDate_lim,
                                      '-01-01', sep=''))

    # Open new plot
    p = ggplot() + theme_ash

    # Margins
    if (first) {
        p = p + 
            theme(plot.margin=margin(t=2.5, r=0, b=3, l=0, unit="mm"))
    } else if (last) {
        p = p + 
            theme(plot.margin=margin(t=2, r=0, b=0, l=0, unit="mm"))
    } else if (first & last) {
        p = p + 
            theme(plot.margin=margin(t=2.5, r=0, b=0, l=0, unit="mm"))
    } else {
        p = p + 
            theme(plot.margin=margin(t=2, r=0, b=2, l=0, unit="mm"))
    }

    
    ## Sub period background ##
    if (!is.null(trend_period)) {
        
        # trend_period = as.list(trend_period)
        # Imin = 10^99
        # for (per in trend_period) {
        #     I = interval(per[1], per[2])
        #     if (I < Imin) {
        #         Imin = I
        #         trend_period_min = as.Date(per)
        #     }
        # }
        # p = p + 
        #     geom_rect(aes(xmin=min(df_data_code$Date),
        #                   ymin=0, 
        #                   xmax=trend_period_min[1],
        #                   ymax= maxQ*1.1),
        #               linetype=0, fill='grey97') +
            
        #     geom_rect(aes(xmin=trend_period_min[2],
        #                   ymin=0, 
        #                   xmax=max(df_data_code$Date), 
        #                   ymax= maxQ*1.1),
        #               linetype=0, fill='grey97') 

        # Convert trend period to list if it is not
        trend_period = as.list(trend_period)
        # Fix a disproportionate minimum for period
        Imin = 10^99
        # For all the sub period of analysis in 'trend_period'
        for (per in trend_period) {
            # Compute time interval of period
            I = interval(per[1], per[2])
            # If it is the smallest interval
            if (I < Imin) {
                # Store it
                Imin = I
                # Fix min period of analysis
                trend_period_min = as.Date(per)
            }
        }
        
        minPer = trend_period_min[1]
        maxPer = trend_period_min[2]

        # If it is not a flow or sqrt of flow time serie
        if (var != 'sqrt(Q)' & var != 'Q') {
            # If there is an 'axis_lim'
            if (!is.null(axis_xlim)) {
                # If the temporary start of period is smaller 
                # than the fix start of x axis limit
                if (minPer < axis_xlim[1]) {
                    # Set the start of the period to the start of
                    # the x axis limit
                    minPer = axis_xlim[1]
                }
            }
        }
        
        # If it is not a flow or sqrt of flow time serie
        if (var != 'sqrt(Q)' & var != 'Q') {
            # If there is an 'axis_lim'
            if (!is.null(axis_xlim)) {
                # If the temporary end of period plus one year 
                # is smaller than the fix end of x axis limit
                if (maxPer + years(1) < axis_xlim[2]) {
                    # Add one year the the temporary end of period
                    maxPer = maxPer + years(1)
                } else {
                    # Set the start of the period to the start of
                    # the x axis limit
                    maxPer = axis_xlim[2]
                }
                # Add one year the the temporary end of period
                # if there is no 'axis_lim'
            } else {
                    maxPer = maxPer + years(1)
            }
        }

        # Draw rectangle to delimiting the sub period
        p = p + 
            geom_rect(aes(xmin=minPer,
                          ymin=minQ_win, 
                          xmax=maxPer,
                          ymax= maxQ_win),
                      linetype=0, fill='grey97')
    }

    ## Mean step ##
    # If there is a 'mean_period'
    if (!is.null(mean_period)) {
        # Convert 'mean_period' to list
        mean_period = as.list(mean_period)
        # Number of mean period
        nPeriod_mean = length(mean_period)

        # Blank tibble to store variable in order to plot
        # rectangle for mean period
        plot_mean = tibble()
        # Blank tibble to store variable in order to plot
        # upper limit of rectangle for mean period
        plot_line = tibble()
        # For all mean period
        for (j in 1:nPeriod_mean) {
            # Get the current start and end of the sub period
            xmin = as.Date(mean_period[[j]][1])
            xmax = as.Date(mean_period[[j]][2])
            
            # Extract the data corresponding to this sub period
            df_data_code_per =
                df_data_code[df_data_code$Date >= xmin
                             & df_data_code$Date <= xmax,]
            
            # If the min over the sub period is greater
            # than the min of the entier period and
            # it is not the first sub period
            if (xmin > min(df_data_code$Date) & j != 1) {
                # Substract 6 months to be in the middle of
                # the previous year
                xmin = add_months(xmin, -6)
            }
            # If it is not a flow or sqrt of flow time serie and
            # it is the first period
            if (var != 'sqrt(Q)' & var != 'Q' & j == 1) {
                # If there is an x axis limit
                if (!is.null(axis_xlim)) {
                    # If the min of the period is before the x axis min
                    if (xmin < axis_xlim[1]) {
                        # The min for the sub period is the x axis
                        xmin = axis_xlim[1]
                    }
                }
            }

            # If the max over the sub period is smaller
            # than the max of the entier period and
            # it is not the last sub period
            if (xmax < max(df_data_code$Date) & j != nPeriod_mean) {
                # Add 6 months to be in the middle of
                # the following year
                xmax = add_months(xmax, 6)
            }
            # If it is not a flow or sqrt of flow time serie and
            # it is the last period
            if (var != 'sqrt(Q)' & var != 'Q' & j == nPeriod_mean) {
                # If there is an x axis limit
                if (!is.null(axis_xlim)) {
                    # If the max of the period plus 1 year
                    # is smaller thant the max of the x axis limit
                    if (xmax + years(1) < axis_xlim[2]) {
                        # Add one year to the max to include
                        # the entire last year graphically
                        xmax = xmax + years(1)
                    } else {
                        # The max of this sub period is the max
                        # of the x axis limit
                        xmax = axis_xlim[2]
                    }
                    # If there is no axis limit
                } else {
                    # Add one year to the max to include
                    # the entire last year graphically
                    xmax = xmax + years(1)
                }
            }
            
            # Mean of the flow over the sub period
            ymax = mean(df_data_code_per$Value, na.rm=TRUE)

            # Create temporary tibble with variable
            # to create rectangle for mean step
            plot_meantmp = tibble(xmin=xmin, xmax=xmax, 
                                  ymin=minQ_win, ymax=ymax, period=j)
            # Bind it to the main tibble to store it with other period
            plot_mean = bind_rows(plot_mean, plot_meantmp)

            # Create vector for the upper limit of the rectangle
            abs = c(xmin, xmax)
            ord = c(ymax, ymax)
            
            # Create temporary tibble with variable
            # to create upper limit for rectangle
            plot_linetmp = tibble(abs=abs, ord=ord, period=j)
            # Bind it to the main tibble to store it with other period
            plot_line =  bind_rows(plot_line, plot_linetmp)
        }
        # Plot rectangles
        p = p + 
            geom_rect(data=plot_mean,
                      aes(xmin=xmin, ymin=ymin, 
                          xmax=xmax, ymax=ymax),
                      linetype=0, fill='grey93')
        # Plot upper line for rectangle
        p = p +
            geom_line(data=plot_line,
                      aes(x=abs, y=ord, group=period),
                      color='grey85',
                      size=0.15)

        
        # for all the sub periods except the last one
        for (i in 1:(nPeriod_mean - 1)) {
            # Computes the time difference in days between periods
            dPeriod = abs(as.Date(mean_period[[i+1]][1]) - as.Date(mean_period[[i]][2]))
                
            if (dPeriod < 10) {
                # The x limit is the x max of the ith rectangle
                xLim = plot_mean$xmax[i]
                # The y limit of rectangle is the max of
                # the two neighboring mean step rectangle
                yLim = max(c(plot_mean$ymax[i], plot_mean$ymax[i+1]))
                # Make a tibble to store data
                plot_lim = tibble(x=c(xLim, xLim), y=c(minQ_win, yLim))
                # Plot the limit of rectangles
                p = p + 
                    geom_line(data=plot_lim, aes(x=x, y=y),
                              linetype='dashed', size=0.15,
                              color='grey85')
                
            } else {
                # Takes the x and y limits for the ith rectangle
                xLim_i = plot_mean$xmax[i]
                yLim_i = plot_mean$ymax[i]
                # Takes the x and y limits for the i+1th rectangle
                xLim_i1 = plot_mean$xmin[i+1]
                yLim_i1 = plot_mean$ymax[i+1]
                
                # Make a tibble to store data
                plot_lim = tibble(x_i=c(xLim_i, xLim_i),
                                  y_i=c(minQ_win, yLim_i),
                                  x_i1=c(xLim_i1, xLim_i1),
                                  y_i1=c(minQ_win, yLim_i1))
                # Plot the limit of rectangles
                p = p + 
                    geom_line(data=plot_lim, aes(x=x_i, y=y_i),
                              linetype='dashed', size=0.15,
                              color='grey85') +
                    geom_line(data=plot_lim, aes(x=x_i1, y=y_i1),
                              linetype='dashed', size=0.15,
                              color='grey85')
            }      
        }
    }

    ### Grid ###
    if (grid) {
        # If there is no axis limit
        if (is.null(axis_xlim)) {
            # The min and the max is set by
            # the min and the max of the date data 
            xmin = min(df_data_code$Date)
            xmax = max(df_data_code$Date)
        } else {
            # Min and max is set with the limit axis parameter
            xmin = axis_xlim[1]
            xmax = axis_xlim[2]
        }
        # Create a vector for all the y grid position
        ygrid = seq(minQ_win, maxQ_win, breakQ)
        # Blank vector to store position
        ord = c() 
        abs = c()
        # For all the grid element
        for (i in 1:length(ygrid)) {
            # Store grid position
            ord = c(ord, rep(ygrid[i], times=2))
            abs = c(abs, xmin, xmax)
        }
        # Create a tibble to store all the position
        plot_grid = tibble(abs=as.Date(abs), ord=ord)
        # Plot the y grid
        p = p +
            geom_line(data=plot_grid, 
                      aes(x=abs, y=ord, group=ord),
                      color='grey85',
                      size=0.15)
    }

    ### Data ###
    # If it is a square root flow or flow
    if (var == 'sqrt(Q)' | var == 'Q') {
        # Plot the data as line
        p = p +
            geom_line(aes(x=df_data_code$Date, y=df_data_code$Value),
                      color='grey20',
                      size=0.3,
                      lineend="round")
    } else {
        # Plot the data as point
        p = p +
            geom_point(aes(x=df_data_code$Date, y=df_data_code$Value),
                       shape=19, color='grey50', alpha=1,
                       stroke=0, size=1)
    }

    ### Missing data ###
    # If the option is TRUE
    if (missRect) {
        # Remove NA data
        NAdate = df_data_code$Date[is.na(df_data_code$Value)]
        # Get the difference between each point of date data without NA
        dNAdate = diff(NAdate)
        # If difference of day is not 1 then
        # it is TRUE for the beginning of each missing data period 
        NAdate_Down = NAdate[append(Inf, dNAdate) != 1]
        # If difference of day is not 1 then
        # it is TRUE for the ending of each missing data period 
        NAdate_Up = NAdate[append(dNAdate, Inf) != 1]

        # Plot the missing data period
        p = p +
            geom_rect(aes(xmin=NAdate_Down, 
                          ymin=minQ_win, 
                          xmax=NAdate_Up, 
                          ymax=maxQ_win),
                      linetype=0, fill='Wheat', alpha=0.4)
    }

    ### Trend ###
    # If there is trends
    if (!is.null(df_trend_code)) {

        # Extract start and end of trend periods
        Start = df_trend_code$period_start
        End = df_trend_code$period_end
        # Get the name of the different period
        UStart = levels(factor(Start))        
        UEnd = levels(factor(End))

        # Compute the max of different start and end
        # so the number of different period
        nPeriod_trend = max(length(UStart), length(UEnd))

        # Blank tibble to store trend data and legend data
        plot_trend = tibble()
        leg_trend = tibble()
        # For all the different period
        for (i in 1:nPeriod_trend) {

            # Extracts the corresponding data for the period
            df_data_code_per =
                df_data_code[df_data_code$Date >= Start[i] 
                             & df_data_code$Date <= End[i],]

            # Computes the mean of the data on the period
            dataMean = mean(df_data_code_per$Value,
                            na.rm=TRUE)
            
            # Get the trend associated to the first period
            df_trend_code_per = 
                df_trend_code[df_trend_code$period_start == Start[i] 
                              & df_trend_code$period_end == End[i],]
            
            # Number of trend selected
            Ntrend = nrow(df_trend_code_per)
            # If the number of trend is greater than a unique one
            if (Ntrend > 1) {
                # Extract only the first hence it is the same period
                df_trend_code_per = df_trend_code_per[1,]
            }            

            # Search for the index of the closest existing date 
            # to the start of the trend period of analysis
            iStart = which.min(abs(df_data_code$Date - Start[i]))
            # Same for the end
            iEnd = which.min(abs(df_data_code$Date - End[i]))

            # Get the start and end date associated
            xmin = df_data_code$Date[iStart]
            xmax = df_data_code$Date[iEnd]

            # If there is a x axis limit
            if (!is.null(axis_xlim)) {
                # If the min of the current period
                # is smaller than the min of the x axis limit
                if (xmin < axis_xlim[1]) {
                    # The min of the period is the min
                    # of the x axis limit
                    xmin = axis_xlim[1]
                }
                # Same for end
                if (xmax > axis_xlim[2]) {
                    xmax = axis_xlim[2]
                } 
            }

            # Create vector to store x data
            abs = c(xmin, xmax)
            # Convert the number of day to the unit of the period
            abs_num = as.numeric(abs) / unit2day
            # Compute the y of the trend
            ord = abs_num * df_trend_code_per$trend +
                df_trend_code_per$intercept

            # Create temporary tibble with variable to plot trend
            # for each period
            plot_trendtmp = tibble(abs=abs, ord=ord, period=i)
            # Bind it to the main tibble to store it with other period
            plot_trend = bind_rows(plot_trend, plot_trendtmp)

            # If there is a x axis limit
            if (!is.null(axis_xlim)) {
                # The x axis limit is selected
                codeDate = axis_xlim
            } else {
                # The entire date data is selected
                codeDate = df_data_code$Date
            }
            # The y limit is stored in a vector
            codeValue = c(minQ_win, maxQ_win)

            # Position of the x beginning and end of the legend symbol
            x = gpct(1.5, codeDate, shift=TRUE)
            xend = x + gpct(3, codeDate)

            # Spacing between legend symbols
            dy = gpct(9, codeValue, min_lim=ymin_lim)
            # Position of the y beginning and end of the legend symbol
            y = gpct(92, codeValue,
                     min_lim=ymin_lim, shift=TRUE) - (i-1)*dy
            yend = y

            # Position of x for the beginning of the associated text
            xt = xend + gpct(1, codeDate)

            # Position of the background rectangle of the legend
            xminR = x - gpct(1, codeDate)
            yminR = y - gpct(5, codeValue, min_lim=ymin_lim)
            # If it is a flow variable
            if (type == 'sévérité') {
                xmaxR = x + gpct(32.5, codeDate)
            # If it is a date variable
            } else if (type == 'saisonnalité') {
                xmaxR = x + gpct(20.5, codeDate)
            }
            ymaxR = y + gpct(5, codeValue, min_lim=ymin_lim)

            # Gets the trend
            trend = df_trend_code_per$trend
            # Gets the p value
            pVal = df_trend_code_per$p
            # Converts it to character
            pValC = as.character(format(round(pVal, 2),
                                         nsmall=2))
            # Computes the mean trend
            trendMean = trend/dataMean
            # Computes the magnitude of the trend
            power = get_power(trend)
            # Converts it to character
            powerC = as.character(power)
            # If the power is positive
            if (powerC >= 0) {
                # Adds a space in order to compensate for the minus
                # sign that sometimes is present for the other periods
                spaceC = '  '
            # Otherwise
            } else {
                # No space is added
                spaceC = ''
            }

            # Gets the power of ten of magnitude
            brk = 10^power
            # Converts trend to character for sientific expression
            trendC = as.character(format(round(trend / brk, 2),
                                         nsmall=2))
            # If the trend is positive