interekt.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Created on Mon May 18 14:14:54 2015

Petite interface graphique pour traiter les tiges ou les racines

@authors: Hugo Chauvet and Félix Hartmann

Changes:
09/04/2021: [Félix] Multilingual support for English, Esperanto and French + bufixes.
05/10/2020: [Félix] A lot of changes: bugfixes for Py2/3 compatibility
                    + multilingual support with gettext (English-only for now)
                    + partial refactoring, for the multilingual support
                    + new ways of estimating the growth length
                    + new estimation of B, with the selection of a steady-state image
04/06/2020: [Félix] Transition to Python3, while maintaining compatibility with Python2.
29/05/2020: [Félix] Adding growth rate estimation for computing beta_tilde and beta_tilde
                    + improved export of phenotyping data to CSV file.
20/01/2020: [Félix] Adding Lagrangian marks
                    + popup window for manualy estimating the growth length using curvature heatmap
06/09/2019: [Hugo] Fin de la première version compatible HDF5
19/07/2019: [Félix] Ajout du calcul de gamma pour expérience sous clinostat, Hugo ajout de la fonction reset_globals_data
04/05/2019: [Hugo] Correct bugs on export when tige_id_mapper was defined with string names for bases. Allow float in the slide to select sensitivity.
24/09/2018: [Hugo] Remove test dectection (ne marche pas en Thread avec matplotlib!) + Correction bug pour traiter une seule image.
08/06/2018: [Hugo] Correct queue.qsize() bug in osX (car marche pas sur cette plateforme
18/04/2018: [Hugo] correct datetime bug. Set percent_diam to 1.4 in MethodOlivier (previous 0.9). Windows system can now use thread
22/10/2017: [Hugo] Optimisation du positionnement du GUI, utilisation de Tk.grid a la place de Tk.pack
16/10/2015: [Hugo] Ajout de divers options pour la tige (suppression etc..) avec menu click droit
                   +Refactorisation de plot_image et de la gestion du global_tige_id_mapper (pour gerer les suppressions)

30/07/2015: [Hugo] Correction bugs pour les racines dans libgravimacro + Ajout visu position de la moyenne de l'ange + Ajout d'options pour le temps des photos
25/05/2015: [Hugo] Ajout des menus pour l'export des moyennes par tiges et pour toutes les tiges + figures
20/05/2015: [Hugo] Première version
"""

from __future__ import (unicode_literals, absolute_import, division, print_function)

import sys, os
if sys.version_info[0] < 3:
    python2 = True
else:
    python2 = False

if python2:
    import Tkinter as Tk, tkFileDialog as filedialog, tkMessageBox as messagebox
    from ttk import Style, Button, Frame, Progressbar, Label, Entry, Scale, Checkbutton
    import Queue as queue
else:
    import tkinter as Tk
    from tkinter import filedialog, messagebox
    from tkinter.ttk import (Style, Button, Frame, Progressbar, Label, Entry, Scale,
                             Checkbutton)
    import queue

if python2:
    import cPickle as pkl

import matplotlib
matplotlib.use('TkAgg')

#Remove zoom key shorcuts
matplotlib.rcParams['keymap.back'] = 'c'
matplotlib.rcParams['keymap.forward'] = 'v'

import matplotlib.pylab as mpl
from matplotlib.collections import LineCollection
from matplotlib.ticker import MultipleLocator
from matplotlib.colors import SymLogNorm
from matplotlib.widgets import RectangleSelector
from matplotlib.backend_bases import key_press_handler
if python2:
    from matplotlib.backends.backend_tkagg import (
        FigureCanvasTkAgg, NavigationToolbar2TkAgg as NavigationToolbar2Tk)
else:
    from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk

from numpy import (array, arange, zeros_like, zeros, ones, linspace, newaxis, NaN, isnan,
                   hstack, ma, exp, log, arctan2, sqrt, sin, cos, pi, mean,
                   timedelta64, argmin, argsort, nonzero, flatnonzero, diff, gradient,
                   rad2deg, deg2rad, quantile,
                   )
from numpy.linalg import norm

from scipy.optimize import fmin
import pandas as pd

import re
finddigits = re.compile(r'\d+?')
from threading import Thread
from collections import OrderedDict

import gettext  # internationalization

from new_libgravimacro import (ProcessImages, traite_tiges2, traite_tige2,
                               get_differential_arc_length,
                               integrate_diff_arc_length,
                               get_tige_curvature,
                               convert_angle,
                               plot_sequence,
                               do_intersect,
                               load_results) # 'load_results' is old method for pkl files

import interekt_hdf5_store as h5store

from Extrawidgets import DraggableLines, DraggablePoints

__version__ = '2020-10-05'

########################## GLOBAL DATA ########################################
strings = dict()  # strings for the user interface, with gettext
tiges_data = None
tiges_names = []
img_object = None
text_object = None
tiges_plot_object = []
base_pts_out = None
base_dir_path = None
cur_image = None
cur_tige = None
toptige = None
add_tige = False
nbclick = 0
base_tiges = []
btige_plt = []
btige_text = []
btige_arrow = []
tiges_colors = None
add_mark = False
marks = []
mark_plt = []
mark_text = []
dtphoto = []
thread_process = None  # To store the thread that run image processing
infos_traitement = None
old_step = 0
add_dist_draw = False
dist_measure_pts = []
pixel_distance = None
cm_distance = None
interekt = None # contains the main window
hdf5file = None # path to hdf5 data file
tk_list_images = None # Tk listbox object which contain the list of images
tk_toplevel_listimages = None # Tk window which displays the list of images
tk_tige_offset = None # contains the offset for tige skeleton detection
tk_tige_percent_diam = None # contains the diameter multplier for the transverse range of tige skeleton detection
tk_detection_step = None  # contains the space step for the skeleton detection process
PERCENT_DIAM_DEFAULT = 1.4    # default value chosen by Hugo
DETECTION_STEP_DEFAULT = 0.3  # default value chosen by Hugo
CURVATURE_AVERAGING_LENGTH = 2  # Length (in cm) of the zone over which the curvature is averaged

def reset_graph_data():
    global img_object, text_object, tiges_plot_object
    global btige_plt, btige_text, btige_arrow
    global mark_plt, mark_text

    img_object = None
    text_object = None
    tiges_plot_object = []
    btige_plt = []
    btige_text = []
    btige_arrow = []
    mark_plt = []
    mark_text = []


def reset_globals_data():
    """
    Reset all global variables, ala Fortran.

    Useful when loading a new file.
    """
    print("Reset all variables and data.")

    global data_out, text_object, tige_plot_object, base_pts_out, base_dir_path
    global cur_image, cur_tige, toptige, add_tige, btige_arrow
    global nbclick, base_tiges, btige_plt, btige_text, tiges_colors
    global marks, mark_plt, mark_text
    global dtphoto, local_photo_path, thread_process, infos_traitement
    global old_step, add_dist_draw, dist_measure_pts, pixel_distance, cm_distance
    global tk_list_images, tk_toplevel_listimages
    global tk_tige_offset, tk_tige_percent_diam, tk_detection_step
    global hdf5file, tiges_data, tiges_names

    # Reset all gl;obalvariables
    # RAZ des autres valeurs
    data_out = None
    img_object = None
    text_object = None
    tige_plot_object = None
    base_pts_out = None
    base_dir_path = None
    cur_image = None
    cur_tige = None
    toptige = None
    add_tige = False
    nbclick = 0
    base_tiges = []
    btige_plt = []
    btige_text = []
    btige_arrow = []
    tiges_colors = None
    add_mark = False
    marks = []
    mark_plt = []
    mark_text = []
    dtphoto = []
    local_photo_path = False  # If true the photo path is removed
    thread_process = None  # To store the thread that run image processing
    infos_traitement = None
    old_step = 0
    add_dist_draw = False
    dist_measure_pts = []
    pixel_distance = None
    cm_distance = None
    tk_list_images = None
    tk_tige_offset = None
    tk_tige_percent_diam = None
    tk_detection_step = None
    hdf5file = None
    tiges_data = None
    tiges_names = []

    # On ferme la liste des images si elle est ouverte
    if tk_toplevel_listimages:
        tk_toplevel_listimages.destroy()
        tk_toplevel_listimages = None

###############################################################################

########################## CONVERT OLD PKL TO HDF5 ############################

def convert_pkl_to_hdf(pklfile, hdf5file, display_message=False, display_progress=False):
    """Converts the olf format .pkl into hdf5."""
    #TODO localize strings
    global tiges_data

    base_dir_path = os.path.dirname(pklfile) + '/'

    # On charge le fichier pkl
    data_out = load_results(pklfile)

    # On convertit les images (avec deux images réduites)

    if display_message:
        interekt.display_message(
                """Ancien format de données: CONVERSION (rootstem_data.pkl -> """
                """interekt_data.h5)\nConversion des images...""")

    Nimgs = len(data_out['tiges_info'])
    for tps_step in data_out['tiges_info']:
        # Test si les images sont disponibles à partir du chemin
        # d'origine ou dans le même dossier que le fichier
        # RootStemData.pkl
        if os.path.exists(tps_step['imgname']):
            img_path = tps_step['imgname']
        else:
            img_path = base_dir_path + os.path.basename(tps_step['imgname'])

        # On affiche l'état d'avancement
        if display_message:
            interekt.display_message(
                    """Ancien format de données: CONVERSION (rootstem_data.pkl -> """
                    """interekt_data.h5)\nConversion des images..."""
                    """(%i/%i)"""%(tps_step['iimg'], Nimgs))

        if display_progress:
            # On augmente la barre de progression du GUI
            dstep = 1/float(Nimgs) * 100.
            #print(dstep)
            interekt.prog_bar.step(dstep)
            interekt.prog_bar.update_idletasks()
            interekt.master.update()

        # On sauvagarde la photo dans le fichier hdf5, on fait garde
        # que le niveau 0 et 2

        # On sauvegarde les valeurs des résolutions de la pyramide
        # juste pour le dernier pas de temps
        store_resolutions = False
        if tps_step['iimg'] == Nimgs-1:
            store_resolutions = True

        h5store.image_to_hdf(hdf5file, img_path,
                             tps_step['iimg'],
                             max_pyramid_layers=2,
                             save_resolutions=store_resolutions,
                             selected_resolutions=[0,2])

    if display_progress:
        # Remise a zero de la progress bar
        interekt.prog_bar.step(0.0)
        interekt.prog_bar.update_idletasks()
        interekt.master.update()

    # Chargement des points de base
    tiges_data = data_out['tiges_data']
    if 'pts_base' in data_out:
        base_tiges = data_out['pts_base']
    else:
        base_tiges = [[(tiges_data.xc[ti,0,0], tiges_data.yc[ti,0,0])]*2 for ti in range(len(tiges_data.yc[:,0,0]))]

    #chargement des numeros des tiges
    if os.path.isfile(base_dir_path+'tige_id_map.pkl'):
        with open(base_dir_path+'tige_id_map.pkl', 'rb') as f:
            datapkl = pkl.load(f)
            tige_id_mapper = datapkl['tige_id_mapper']

            # Cherche si il y a d'autre données du post-processing a
            # charger Leur nom de variable est le même que la clef du
            # dico, on utilise la fonction eval pour créer la variable
            # Expl: scale_cmpix = datapkl['scale_cmpix']
            for dname in ('scale_cmpix', 'growth_data', 'B_data', 'beta_data',
                          'gamma_data', 'End_point_data', 'Tiges_seuil_offset'):

                if dname in datapkl:
                    exec("%s = datapkl['%s']" % (dname, dname))
                else:
                    #Creation d'un dico vide
                    exec("%s = {}" % (dname))
    else:
        tige_id_mapper = {}

    # Création des dossiers des tiges et du tige_id_mapper si il n'a
    # pas été defini dans le fichier tige_id_map.pkl
    for it in range(len(base_tiges)):
        h5store.create_tige_in_hdf(hdf5file, it)
        if it not in tige_id_mapper:
            tige_id_mapper[it] = it + 1

    # On lance le postrocessing des données des squelette des tiges
    # pour les enregistrer ensuite dans le fichier hdf5
    Traite_data(save_to_hdf5=True)

    # Pour l'échelle de l'image
    scale_cmpix = None

    # Chargement des données du traitement dans le fichier hdf5
    for id_tige in range(len(base_tiges)):
        # Est ce qu'il y a un nom pour cette tige
        if id_tige in tige_id_mapper:
            tige_nom = tige_id_mapper[id_tige]
        else:
            tige_nom = ""

        if display_message:
            interekt.display_message(
                    """Ancien format de données: CONVERSION (rootstem_data.pkl -> """
                    """interekt_data.h5)\nConversion des squelettes..."""
                    """(tige %i/%i)"""%(id_tige+1, len(base_tiges)))

        h5store.tige_to_hdf5(hdf5file, id_tige, tige_nom, base_tiges[id_tige],
                             tiges_data.xc[id_tige], tiges_data.yc[id_tige],
                             tiges_data.theta[id_tige], tiges_data.diam[id_tige],
                             tiges_data.xb1[id_tige], tiges_data.yb1[id_tige],
                             tiges_data.xb2[id_tige], tiges_data.yb2[id_tige])

        # Enregistrement des données comme dans fonction l'ancienne
        # fonction save_tige_idmapper() On sauve aussi cet ancien
        # tige_id_mapper dans le champ 'name' de la tige qui est plus
        # logique et qui serra dorénavant utilisé
        postprocess_data = {'OLD_tige_id_mapper': tige_id_mapper[id_tige]}

        h5store.save_tige_name(hdf5file, id_tige, str(tige_id_mapper[id_tige]))

        # On boucle sur les autres données du post-processing leur nom
        # est le même que le nom de la variable
        for dname in ('growth_data', 'B_data', 'beta_data', 'gamma_data',
                      'End_point_data', 'Tiges_seuil_offset'):
            try:
                postprocess_data[dname] = eval('%s[%i]' % (dname, id_tige))
            except Exception as e:
                print('No postprocessing data %s for tige %i' % (dname, id_tige))
                print(e)

            # On enregistre la valeur de l'échelle pour la sauvegarder
            # dans la H5 une seule fois à la fin
            if 'scale_cmpix' in postprocess_data:
                scale_cmpix = postprocess_data['scale_cmpix']

        # Cas un peu particulier de B_data qui contient des clefs
        # avec des '/' ce qui fait des sous-dossiers dans le
        # fichier h5, il faut donc les changer
        if 'B_data' in postprocess_data:
            if 'Lc (fit Log(A/A0))' in postprocess_data['B_data']:
                try:
                    postprocess_data['B_data']['Lc (fit Log(A over A0))'] = postprocess_data['B_data'].pop('Lc (fit Log(A/A0))')
                except:
                    print('Pas capable de convertir la clef "Lc (fit Log(A/A0))"')

            if 'Lc (fit exp(A/A0))' in postprocess_data['B_data']:
                try:
                    postprocess_data['B_data']['Lc (fit exp(A over A0))'] = postprocess_data['B_data'].pop('Lc (fit exp(A/A0))')
                except:
                    print('Pas capable de convertir la clef "Lc (fit exp(A/A0))"')

        h5store.save_tige_dict_to_hdf(hdf5file, id_tige, postprocess_data)

    # Sauvegarde de l'échelle
    h5store.save_pixelscale(hdf5file, scale_cmpix)

###############################################################################

def set_tiges_colormap():
    global tiges_colors
    #Fonction pour construire le vecteur des couleurs pour les tiges
    if len(base_tiges) > 20:
        s = len(base_tiges)+1
    else:
        s = 20

    try:
        tiges_colors = mpl.cm.tab20(linspace(0, 1, s))
    except Exception as e:
        print(e, "Update Matplotlib!")
        tiges_colors = mpl.cm.hsv(linspace(0, 1, s))

def get_hdf5_tigeid(h5file, gui_tige_id):
    """Returns the id under which the tige is saved in the hdf5 file."""

    tiges_ids = h5store.get_tiges_indices(h5file)
    tigeid = tiges_ids[gui_tige_id]

    return tigeid

def load_hdf5_tiges(hdf5file, display_message=True):
    """
    Fonction pour recharger toutes les tiges depuis le fichier hdf5
    vers les variables globales d'Interekt.

    load_data: permet de charger en mémoire les données tiges_data et
               celle du post_processing pour afficher les profils des
               tiges voir la fonction Load_postprocessed_data()
    """
    global tiges_data, base_tiges, btige_plt, btige_text, tiges_names
    global tiges_plot_object

    # On trouve combien on a de tiges traitées
    Ntiges = h5store.get_number_of_tiges(hdf5file)

    # On crée les listes pour stoker les textes et les plots
    # pour chaque tiges
    btige_plt = [None]*Ntiges
    btige_text = [None]*Ntiges
    tiges_plot_object = [None]*Ntiges

    # Chargement du nom des tiges
    if display_message:
        interekt.display_message(_("""Loading data"""))
    tiges_names = h5store.get_tiges_names(hdf5file)
    base_tiges = h5store.get_tiges_bases(hdf5file)
    #Recharge la colormap pour les tiges ouvertes
    set_tiges_colormap()

    #Traitement des données
    print("Loading data from the h5 file")
    tiges_data = h5store.get_tigesmanager(hdf5file)

    # For each tige, let's check whether useful data have been stored by 'Traite_data'
    for tige_id in range(Ntiges):
        # Let's get the id of the tige in the hdf5 file
        hdf_tige_id = get_hdf5_tigeid(hdf5file, tige_id)
        angle = h5store.get_postprocessing(hdf5file, 'angle', hdf_tige_id)
        if angle is None:
            Traite_data(save_to_hdf5=True)

def load_hdf5_file(hdf5file):
    """Loads a hdf5 file into Interekt."""
    global dtphoto

    # On charge les données des tiges
    load_hdf5_tiges(hdf5file)

    interekt.get_photo_datetime.set(True)

    # Doit on charger le temps des photos
    #if interekt.get_photo_datetime.get():
    dtphoto = h5store.get_images_datetimes(hdf5file)

    # On regarde si tous les temps sont des datetime sinon on
    # prends le numéro de la photo
    for t in dtphoto:
        if t is None:
            print("Error: No timestamp for all photos; photo numbers are used instead.")
            dtphoto = []
            break

    # Si pas de temps dans les photos on mets l'option dans
    # l'interface graphique à False
    if dtphoto == []:
        interekt.get_photo_datetime.set(False)

    # Retrieve the data on the steady state from the h5 file
    steady_state, exclude_steady_state = h5store.get_steady_state(hdf5file)
    interekt.steady_state_image = steady_state
    interekt.exclude_steady_state_from_time_series.set(exclude_steady_state)


######################### HANDLING OF THE IMAGE LIST ##########################

def onChangeImage(event):
    try:
        sender = event.widget
        idx = sender.curselection()
        #print("idx %i"%idx)
        interekt.plot_image(idx[0], keep_zoom=True)
    except Exception as e:
        print("Erreur de chargement !!!")
        print(e)

def show_image_list():
    global tk_list_images, tk_toplevel_listimages

    if tk_toplevel_listimages is None:
        tk_toplevel_listimages = Tk.Toplevel(master=root)
        tk_toplevel_listimages.title(_("List of open images"))

        topsbar = Tk.Scrollbar(tk_toplevel_listimages, orient=Tk.VERTICAL)
        listb = Tk.Listbox(master=tk_toplevel_listimages,
                           yscrollcommand=topsbar.set)
        topsbar.config(command=listb.yview)
        topsbar.pack(side=Tk.RIGHT, fill=Tk.Y)

        for imgname in h5store.get_images_names(hdf5file):
            listb.insert(Tk.END, imgname)

        # Selection de l'image que l'on regarde
        if cur_image:
            listb.selection_set(cur_image)
            listb.see(cur_image)
        else:
            listb.selection_set(0)
            listb.see(0)

        listb.bind("<<ListboxSelect>>", onChangeImage)
        listb.pack(side=Tk.LEFT, fill=Tk.BOTH, expand=1)
        tk_list_images = listb

        # Signal pour déclencher la fonction qui ferme proprement la
        # liste d'image en gérant les globals
        tk_toplevel_listimages.protocol("WM_DELETE_WINDOW", destroy_list_images)

    else:
        # Si la fenêtre existe déjà mais est cachée on la ramène devant
        tk_toplevel_listimages.lift()

def destroy_list_images():
    """Safely closed the image list window."""
    global tk_list_images, tk_toplevel_listimages

    # On détruit la fenetre
    tk_toplevel_listimages.destroy()

    # On remet les variables global à None (Fortran Style)
    tk_list_images = None
    tk_toplevel_listimages = None

###############################################################################


########################## HANDLING OF TIMES ##################################

def get_time_data():
    """Returns useful variables for plotting time series.

    Returns:
    --------
    - times: 1D array of photo times
    - time_units: dictionary with time-related units
    - time_label: label for the time axis in plots (str)
    - graduation: on the time axis of a plot, a tick will be placed
      at each multiple of 'graduation'
    - excluded_image: index of the image to be excluded from time
      series (otberwise, 'None')
    - mask: a mask array for excluding the above-mentioned image
    """

    nb_images = h5store.get_number_of_images(hdf5file)

    # We define a mask which will be useful if the steady-state image
    # has to be excluded from time series.
    mask = ones(nb_images, dtype=bool)
    if (interekt.steady_state_image is not None
            and interekt.exclude_steady_state_from_time_series.get()):
        excluded_image = interekt.steady_state_image
        mask[excluded_image] = False
    else:
        excluded_image = None

    if interekt.get_photo_datetime.get() and dtphoto:
        # photos have timestamps

        # time in minutes
        times = array([(t - dtphoto[0]).total_seconds() for t in dtphoto]) / 60.

        # total duration of the experiment in minutes
        total_minutes = times[mask].max()

        # choose time unit and graduation for the graphs,
        # based on the total duration
        if total_minutes < 12 * 60:  # less than 12 hours
            time_unit = strings["min"]
            graduation = 60   # a graduation every hour
        elif total_minutes < 24 * 60:  # between 12 and 24 hours
            times /= 60  # time in hours
            time_unit = strings["hours"]
            graduation = 1   # a graduation every hour
        elif total_minutes <  7 * 24 * 60:  # between one day and one week
            times /= 60  # time in hours
            time_unit = strings["hours"]
            graduation = 24   # a graduation every day
        elif total_minutes < 30 * 24 * 60:  # between one week and one month
            times /= 24 * 60  # time in days
            time_unit = strings["days"]
            graduation = 1   # a graduation every day
        elif total_minutes < 3 * 30 * 24 * 60:  # between one month and three month
            times /= 24 * 60  # time in days
            time_unit = strings["days"]
            graduation = 7   # a graduation every week
        elif total_minutes >= 3 * 30 * 24 * 60:  # more than three month
            times /= 24 * 60  # time in days
            time_unit = strings["days"]
            graduation = 30   # a graduation every 30 days

        time_label = strings["time"] + " (%s)"%time_unit
        time_units = {"time unit": time_unit,
                      "RER unit": "h-1",
                      "RER unit TeX": r"h$^{-1}$",
                      "dAdt unit": "rad.h-1",
                      "dAdt unit TeX": r"rad.h$^{-1}$"}

    else:
        times = arange(1, nb_images+1)  # time = image number

        # one tick every 60 minutes if photos taken every 6 minutes
        # (this is a legacy from the Murinas project)
        graduation = 10

        time_label = strings["image number"]
        RER_unit = strings["image"] + "-1"
        RER_unit_TeX = strings["image"] + r"$^{-1}$"
        time_units = {"time unit": strings["image"],
                      "RER unit": RER_unit,
                      "RER unit TeX": RER_unit_TeX,
                      "dAdt unit": "rad." + RER_unit,
                      "dAdt unit TeX": r"rad." + RER_unit_TeX}

    return times, time_units, time_label, graduation, excluded_image, mask


##########W####################################################################


########################## Pour le Traitement #################################
def _export_to_csv():
    """
    Fonction pour exporter la serie temporelle pour les tiges soit
    l'évolution de l'angle moyen au bout et de la taille au cours du
    temps
    """

    if len(base_tiges) > 0:
        proposed_filename = "time_series_tipangle_length.csv"
        outfileName = filedialog.asksaveasfilename(
                parent=root,
                filetypes=[("Comma Separated Value, csv","*.csv")],
                title=_("Export time series"),
                #title=_("Export séries temporelles"),
                initialfile=proposed_filename,
                initialdir=base_dir_path)

    if len(outfileName) > 0:

        # Creation du tableau Pandas pour stocquer les données
        data_out = pd.DataFrame(columns=['tige', 'angle', 'temps',
                                         'taille', 'rayon', 'angle_0_360'])

        # Récupérations des id des tiges dans le fichier h5
        hdf_tiges_id = h5store.get_tiges_indices(hdf5file)
        tiges_names = h5store.get_tiges_names(hdf5file)
        pictures_names = h5store.get_images_names(hdf5file)

        # Récupère le temps
        if interekt.get_photo_datetime.get() and dtphoto:
            tps = dtphoto
        else:
            tps = arange(len(pictures_names))

        # Boucle sur les tiges
        for i in range(len(base_tiges)):

            hdfid = hdf_tiges_id[i]
            tige_x, tige_y, tige_s, tige_taille, tige_angle, tige_tip_angle, tige_zone,\
                    _ = load_postprocessed_data(hdf5file, hdfid)
            tige_R = tiges_data.diam[i]/2.0
            tige_name = tiges_names[i]

            data_tmp = pd.DataFrame({'tige': tige_name, 'angle': tige_tip_angle,
                                     'temps': tps, 'taille': tige_taille,
                                     'rayon': tige_R.mean(1),
                                     'angle_0_360': convert_angle(tige_tip_angle)})

            data_out = data_out.append(data_tmp, ignore_index=True)

        #Add some usefull data
        #Ntige = data_out.tige.unique()
        output = []
        #print Ntige
        for tige, datatige in data_out.groupby('tige'):
            # print(dataout.tige)

            #Compute dt (min)
            if interekt.get_photo_datetime.get():
                dtps = (datatige['temps']-datatige['temps'].min())/timedelta64(1,'m')
                datatige.loc[:,'dt (min)'] = dtps

            datatige.loc[:,'pictures name'] = pictures_names

            # Trouve la position de la tige dans les données du GUI
            itige = tiges_names.index(tige)

            datatige.loc[:,'x base (pix)'] = [tiges_data.xc[itige,:,0].mean()]*len(datatige.index)
            output += [datatige]

        dataout = pd.concat(output)
        print(dataout.head())
        #print datatige.tail()
        dataout.to_csv(outfileName, index=False)

def _export_xytemps_to_csv():
    """
    Export du squelette des tiges/racines au cours du temps sous
    format csv, pour un pas de temps on aura le xy complet (soit pour
    chaque abscisse curviligne).
    """

    if len(base_tiges) > 0:
        proposed_filename = "skeleton.csv"
        outfileName = filedialog.asksaveasfilename(
                parent=root,
                filetypes=[("Comma Separated Value, csv","*.csv")],
                title=_("Export skeleton"),
                initialfile=proposed_filename,
                initialdir=base_dir_path)

    if len(outfileName) > 0:
        # Creation du tableau Pandas pour stocquer les données
        data_out = pd.DataFrame(columns=['tige', 'angle', 'temps',
                                         'taille', 'rayon', 'x', 'y', 'nom photo',
                                         'angle_0_360'])

        # Récupérations des id des tiges dans le fichier h5
        hdf_tiges_id = h5store.get_tiges_indices(hdf5file)
        tiges_names = h5store.get_tiges_names(hdf5file)
        pictures_names = h5store.get_images_names(hdf5file)

        # Récupère le temps
        if interekt.get_photo_datetime.get() and dtphoto:
            tps = dtphoto
        else:
            tps = arange(len(pictures_names))

        # Boucle sur les tiges
        for i in range(len(base_tiges)):

            hdfid = hdf_tiges_id[i]
            tige_x, tige_y, tige_s, tige_taille, tige_angle, tige_tip_angle, tige_zone,\
                    _ = load_postprocessed_data(hdf5file, hdfid)
            tige_R = tiges_data.diam[i]/2.0
            tige_name = tiges_names[i]

            data_tmp = pd.DataFrame({'tige': tige_name, 'angle': tige_tip_angle,
                                     'temps': tps, 'taille': tige_taille,
                                     'rayon': tige_R.mean(1),
                                     'x': tige_x.tolist(),
                                     'y': tige_y.tolist(),
                                     'nom photo': pictures_names,
                                     'angle_0_360': convert_angle(tige_tip_angle)})

            data_out = data_out.append(data_tmp, ignore_index=True)

        print(data_out.head())
        print("Enregistré dans %s" % outfileName)
        data_out.to_csv(outfileName, index=False)

def _export_mean_to_csv():
    """
    Fonction qui exporte la courbe moyennée pour toutes les tiges de
    l'angle et taille en fonction du temps
    """

    if len(base_tiges) > 0:
        proposed_filename = "Serie_tempotelle_moyenne.csv"
        outfileName = filedialog.asksaveasfilename(
                parent=root,
                filetypes=[("Comma Separated Value, csv","*.csv")],
                title="Export serie temporelle",
                initialfile=proposed_filename,
                initialdir=base_dir_path)

    if len(outfileName) > 0:

        # Creation du tableau Pandas pour stocquer les données
        data_out = pd.DataFrame(columns=['tige', 'angle', 'temps',
                                         'taille', 'rayon', 'angle_0_360'])

        # Récupérations des id des tiges dans le fichier h5
        hdf_tiges_id = h5store.get_tiges_indices(hdf5file)
        tiges_names = h5store.get_tiges_names(hdf5file)
        pictures_names = h5store.get_images_names(hdf5file)

        # Récupère le temps
        if interekt.get_photo_datetime.get() and dtphoto:
            tps = dtphoto
        else:
            tps = arange(len(pictures_names))

        # Boucle sur les tiges
        for i in range(len(base_tiges)):

            hdfid = hdf_tiges_id[i]
            tige_x, tige_y, tige_s, tige_taille, tige_angle, tige_tip_angle, tige_zone,\
                    _ = load_postprocessed_data(hdf5file, hdfid)
            tige_R = tiges_data.diam[i]/2.0
            tige_name = tiges_names[i]

            data_tmp = pd.DataFrame({'tige': tige_name, 'angle': tige_tip_angle,
                                     'temps': tps, 'taille': tige_taille,
                                     'rayon': tige_R.mean(1),
                                     'angle_0_360': convert_angle(tige_tip_angle)})

            data_out = data_out.append(data_tmp, ignore_index=True)


        #Creation de la moyenne
        datamoy = data_out.groupby('temps').mean()
        datamoy['temps'] = data_out.temps.unique()
        datamoy['tige'] = ['%s->%s'%(str(data_out['tige'].min()),
                                     str(data_out['tige'].max()))]*len(datamoy['temps'])

        #Convert to timedelta in minute
        if interekt.get_photo_datetime.get():
            dtps = (datamoy['temps']-datamoy['temps'][0])/timedelta64(1,'m')
            datamoy['dt (min)'] = dtps

        datamoy['pictures name'] = pictures_names
        print("Saved to %s"%outfileName)
        datamoy.to_csv(outfileName, index=False)

def _export_meandata_for_each_tiges():
    """
    Dans un dossier donnée par l'utilisateur on exporte les données
    taille et angle au cours de temps avec un fichier .csv par
    tiges/racines
    """

    #Ask for a directory where to save all files
    outdir = filedialog.askdirectory(
            title="Choisir un répertoire pour sauvegarder les tiges")
    if len(outdir) > 0:
        # Creation du tableau Pandas pour stocquer les données
        data_out = pd.DataFrame(columns=['tige', 'angle', 'temps',
                                         'taille', 'rayon', 'angle_0_360'])

        # Récupérations des id des tiges dans le fichier h5
        hdf_tiges_id = h5store.get_tiges_indices(hdf5file)
        tiges_names = h5store.get_tiges_names(hdf5file)
        pictures_names = h5store.get_images_names(hdf5file)

        # Récupère le temps
        if interekt.get_photo_datetime.get() and dtphoto:
            tps = dtphoto
        else:
            tps = arange(len(pictures_names))

        # Boucle sur les tiges
        for i in range(len(base_tiges)):

            hdfid = hdf_tiges_id[i]
            tige_x, tige_y, tige_s, tige_taille, tige_angle, tige_tip_angle, tige_zone,\
                    _ = load_postprocessed_data(hdf5file, hdfid)
            tige_R = tiges_data.diam[i]/2.0
            tige_name = tiges_names[i]

            data_tmp = pd.DataFrame({'tige': tige_name, 'angle': tige_tip_angle,
                                     'temps': tps, 'taille': tige_taille,
                                     'rayon': tige_R.mean(1),
                                     'angle_0_360': convert_angle(tige_tip_angle)})

            data_out = data_out.append(data_tmp, ignore_index=True)

        #Loop over tiges
        # Ntige = dataframe.tige.unique()
        for tige, datatige in data_out.groupby('tige'):
            #Compute dt (min)
            if interekt.get_photo_datetime.get():
                dtps = (datatige['temps']-datatige['temps'][datatige.index[0]])/timedelta64(1,'m')
                datatige['dt (min)'] = dtps

            datatige['pictures name'] = pictures_names
            # Trouve la position de la tige dans les données du GUI
            itige = tiges_names.index(tige)
            datatige['x base (pix)'] = [tiges_data.xc[itige,:,0].mean()]*len(datatige.index)

            #print datatige.head()
            outfileName = outdir+'/data_mean_for_tige_%s.csv'%str(tige)
            print("Sauvegardé dans %s"%outfileName)
            datatige.to_csv(outfileName, index=False)

###############################################################################

def update_tk_progress(infos, root):
    global old_step
    if infos is not None:

        im_num = infos['inum']
        old_num = infos['old_inum']
        tot = infos['tot']
        start_msg = _("Image processing")
        msg = start_msg + " %i / %i"%(int(im_num),int(tot))
        root.wm_title("Interekt | %s"%msg)
        root.update_idletasks()

        #New version with Tk progressbar
        if im_num != old_step and tot > 1:
            old_step = im_num
            #print(old_step, nstep, nstep-old_step)
            dstep = (im_num-old_num)/float(tot-1) * 100.
            #print(dstep)
            interekt.prog_bar.step(dstep)
            interekt.prog_bar.update_idletasks()
            root.update()

def plot_progress(**kwargs):
    global infos_traitement
    infos_traitement = kwargs

def none_print(**kwargs):
    output = kwargs

def check_process():
    global root, infos_traitement

    if thread_process.is_alive():
        update_tk_progress(infos_traitement, root)
        root.after(20, check_process)

    else:
        update_tk_progress(infos_traitement, root)
        root.wm_title("Interekt")
        thread_process.join()
        infos_traitement = None
        try:
            process_data()
        except Exception as e:
            print('Failed to process data')
            print(e)

def process_data(display_message=True):
    global data_out, tiges_data

    # Get queue result
    data_out = data_out.get()

    # When it's done get the tiges_data from the data from data_out
    tiges_data = data_out['data']['tiges_data']

    # On affiche que l'on fait la sauvegarde
    if display_message:
        interekt.display_message(_("Saving data into the .h5 file"))
    for idt in range(len(base_tiges)):
        # Recup l'id dans le fichier hdf
        idhdf = get_hdf5_tigeid(hdf5file, idt)
        tige_name = h5store.get_tiges_names(hdf5file, idhdf)
        h5store.tige_to_hdf5(hdf5file, idhdf, tige_name, base_tiges[idt],
                             tiges_data.xc[idt], tiges_data.yc[idt],
                             tiges_data.theta[idt], tiges_data.diam[idt],
                             tiges_data.xb1[idt], tiges_data.yb1[idt],
                             tiges_data.xb2[idt], tiges_data.yb2[idt])

    # On lance le traitement et on le sauvegarde dans le fichier hdf5
    if display_message:
        interekt.display_message(_("Processing extracted data"))