PROGRAMME : #

PROGRAMME :

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

# PROJET BAC OCEANE ET DIANE : LA CIA, Conduite Intelligente et Accompagnée !

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

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

# Imports

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

# -*- coding: utf-8 -*-

from __future__ import division

from __future__ import unicode_literals

from Tkinter import *  #permet de créer une interface graphique

from PIL import Image, ImageTk  #permet d'insérer des images

from math import * #permet d'utiliser le module math

from datetime import date #permet de gérer les objets dates

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

# Fonctions des boutons

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

# Fonction quitter

def Fonction_quitter(): #cette fonction permet de fermer la fenetre en cliquant sur quitter

    Fenetre.destroy()

# Fonction qui créé un fichier (situé au même endroit que le programme) dans lequel seront stockées les infos enregistrées par l'utilisateur

# Elle contient aussi tous les conseils, informations, gestion des erreurs.

def Donnees():

    chaine_nbrkm = str(Nbr_km.get()) #Récupère le contenu entré par l'utilisateur dans le nbr de km, str transforme l'entier en chaîne

    import tkMessageBox #module qui permet de créer des boites de dialogues ou d'informations

    if (chaine_nbrkm.isdigit()) == False:  # isdigit renvoie True si 'chaine' est un nombre et False si ça n'en est pas

        tkMessageBox.showinfo("Erreur","Erreur d'entrée du nombre de kilomètres. Recommencez !") # Si ca n'en est pas, une fenetre d'info s'ouvre pour prévenir l'utilisateur

    else: # Si c'est un nombre, le programme démarre

        Profil = open("donnees"+".txt",'a') #création et ouverture en modification (pour ajouter des données) du fichier appelé donnees

        Profil.write(str(Nbr_km.get())+'\n')       #Récupération des infos des cases cochées dans la partie formulaire

        Profil.write(str(date_01.get())+'\n')

        Profil.write(str(variablemeteo.get())+'\n')

        Profil.write(str(variabletrafic.get())+'\n')

        Profil.write(str(variabletypederoute.get())+'\n')

        Profil.write(str(variablejour_nuit.get())+'\n')

        Profil.close() #on referme le fichier, obligatoire s'il a été ouvert

    # Cette partie consiste à créer des listes spécifiques pour chaque paramètre (nombre de km, date, météo, trafic, type de route, jour ou nuit..)

        Profil_fichier = open("donnees"+".txt",'r') #ouverture du fichier donnees en lecture

        Liste_fichier = [] #on crée une liste vide qui contiendra les informations du fichier

        Liste_fichier = Profil_fichier.readlines() #on met toutes les lignes du fichier dans la liste vide

        Nb_bloc = (len(Liste_fichier))/6 #calcul du nombre de "blocs", chaque bloc contenant 6 lignes on divise la longueur de la liste renvoyé par len() par six

        Profil_fichier.close()

# Création des listes vides correspondant chacune à une condition de conduite remplie par l'utilisateur, on utilise global pour pouvoir

# les modifier à partir de n'importe quelle partie du programme

        Nb_Km = []

        global Nb_Km

        Date = []

        global Date

        Meteo = []

        global Meteo

        Trafic = []

        global Trafic

        Route = []

        global Route

        JN = []

        global JN

#Boucle for allant de 0 au nombre de blocs*6 (pour avoir le nombre de lignes total du programme) par saut de 6 (par bloc): on prend les six premières lignes qu'on répartit chacune dans les listes précédemment

# créées, ensuite on passe six lignes plus loin donc au 2e bloc et on recommence jusqu'à avoir réparti tout le contenu du fichier dans les listes.

        for i in range(0,int(Nb_bloc)*6,6):

            Nb_Km.append(Liste_fichier[i]) #[i] représente le rang de la ligne qu'on ajoute à la liste par la commande append()

            Date.append(Liste_fichier[i+1])

            Meteo.append(Liste_fichier[i+2])

            Trafic.append(Liste_fichier[i+3])

            Route.append(Liste_fichier[i+4])

            JN.append(Liste_fichier[i+5])

        # Compteur kilométrique

        Total_km = 0 #on définit une variable qui sera le compteur kilométrique

        # On utilise une boucle qui parcourt la liste où sont stockés les kms entrés par l'utilisateur, elle va de 0 au nombre de blocs (=nb d'éléments dans la liste)

        for compteur in range (0,int(Nb_bloc)):

            Total_km = int(Total_km) + int(Nb_Km[int(compteur)]) #on incrémente la variable Total_km à chaque tour des nombres de la liste

                                                                 # int définit la variable comme un chiffre

        #On modifie avec config() le label indiquant le comptage kilométrique pour qu'il s'actualise et affiche le total des km parcourus sur l'interface graphique

        km_parcourus.config(text ='Tu as parcouru'+" "+str(Total_km)+" "+'kilomètres au total.')

        # Gestion date

        # On définit la première date comme étant la première qui fut entrée par l'utilisateur, on la prend donc dans la liste contenant les dates à la première place

        premiere_date = Date[0]

        #Cette date est sous forme AAAA/MM/JJ donc avec split() on renvoie une nouvelle liste contenant les différents éléments séparés par "/"

        datelist = premiere_date.split("/")

        # Des variables prendront la valeur des éléments de la nouvelle liste

        An = int(datelist[0])

        Mois = int(datelist[1])

        Jour = int(datelist[2])

        # On assemble les variables précédentes en un objet date

        premier_jour = date(An, Mois, Jour)

        # On récupère la date d'aujourd'hui avec date.today()

        aujourdhui = date.today()

        # On soustrait la première date à celle d'aujourd'hui pour savoir depuis combien de temps notre apprenti est accompagnée en conduite !

        temps_depuis_debut = aujourdhui-premier_jour

        # On convertit cette durée en secondes avec .total_second() et on la divise par 86400 (nb de sec en 1jour) pour au final connaitre cette durée en jours

        nbre_jours=int(temps_depuis_debut.total_seconds()/86400)

        Temps_utilise.config(text=str(nbre_jours)+" "+"jours déjà que tu as commencé la conduite accompagnée !") #on modifie un label de l'interface graphique pour l'informer

        # Par la même occasion on calcule combien de temps il reste à notre apprenti (en supposant que la conduite accompagnée dure un an soit 365 jours)

        temps_restant = 365-nbre_jours

        Temps_restant.config(text=str(temps_restant)+" "+"jours restants pour finir tes 3000km !")#on modifie un label de l'interface graphique pour l'informer

        # Calcul de combien de km il est supposé avoir fait : on multiplie le nbr de jours depuis lesquels il conduit par la moyenne de 3000km en 365 jours

        # On utilise ceil() qui arrondit le résultat par excès

        km_esperes = ceil(nbre_jours*(3000/365))

        # Condition if : on compare le total de km parcourus avec le nombre de km qu'il est supposé avoir fait. On modifie un label de l'interface graphique partie conseil en

         # fonction du résultat de la comparaison ...

        if km_esperes>Total_km:

            Comparaison_moyenne.config(text=" Il est temps de prendre le volant plus souvent !")

        else:

            Comparaison_moyenne.config(text=" Continue ainsi !")

    # Dans cette partie on va déterminer quelles conditions notre utilisateur expérimente en majorité

    # Condition météo +++

        Max_meteo = 0 #variable servant de maximum provisoire

        #Boucle parcourant la liste contenant les infos sur la météos

        for i in range (0,len(Meteo)):

            variable_meteo = Meteo[i] #la variable_meteo contient successivement tous les éléments de la liste

            if int(Meteo.count(variable_meteo))>=Max_meteo: #si le nombre de fois qu'elle est présente dans la liste est plus grand que le maximum alors il devient le maximum

                Max_meteo = int(Meteo.count(variable_meteo)) #ainsi on a le plus grand nombre de fois qu'une variable est présente dans la liste

        # on reparcourt la liste, car on a un simple nombre et non une variable ...

        for compteur in range(0,len(Meteo)):

            variable_meteo_2 = Meteo[compteur] #une 2e variable prendra successivement les valeurs de la liste

            if Max_meteo == Meteo.count(variable_meteo_2): # si le nombre de fois qu'elle est présente dans la liste correspond à notre maximum c'est gagné : c'est elle

                                                            # la condition météo la plus rencontrée

                Meteo_Plus.config(text = "Ta condition météorologique préférée : "+str(variable_meteo_2.lower())) #on modifie un label d'information

   #Lower permet de mettre tous les caractères en minuscules

    # On fait de même avec les autres paramètres (en changeant les variables cela va de soi) :

    # Condition trafic +++

        Max_trafic = 0

        for i in range (0,len(Trafic)):

            variable_trafic = Trafic[i]

            if int(Trafic.count(variable_trafic))>=Max_trafic:

                Max_trafic = int(Trafic.count(variable_trafic))

        for compteur in range(0,len(Trafic)):

            variable_trafic_2 = Trafic[compteur]

            if Max_trafic == Trafic.count(variable_trafic_2):

                Trafic_Plus.config(text ="Tu conduis souvent avec un trafic"+' '+str(variable_trafic_2.lower()))

    # Type route +++

        Max_route = 0

        for i in range (0,len(Route)):

            variable_route = Route[i]

            if int(Route.count(variable_route))>=Max_route:

                Max_route = int(Route.count(variable_route))

        for compteur in range(0,len(Route)):

            variable_route_2 = Route[compteur]

            if Max_route == Route.count(variable_route_2):

                Route_Plus.config(text ="Ton type de route préféré : "+' '+str(variable_route_2.lower()))

    # Jour/ Nuit +++

    # Sachant qu'il n'y a que deux possibilité ici, on a codé autrement :

        Jour1 = JN.count('De jour\n') # 2 variables prennent la valeur du nbr de fois que jour et nuit sont présents dans la liste

        Nuit1 = JN.count('De nuit\n')

        if Jour1>=Nuit1: #si jour est présent plus de fois que nuit on modifie le label avec un certain texte

            JN_Plus.config(text ='Oiseau du jour bonjour !')

        else: #sinon c'est nuit qui est plus présent donc autre modification du label en conséquence

            JN_Plus.config(text ='Serais-tu un oiseau de nuit ?')

    # Partie conseils ! Les conseils apparaissent seulement après avoir cliqué sur enregistrer !

    # Condition météo ---

        Min_meteo = 100000 #on définit un minimum provisoire

        for i in range (0,len(Meteo)): #on parcourt la liste contenant les conditions météo

            variable_meteo_3 = Meteo[i] #une variable prend successivement la valeur des éléments de la liste

            if int(Meteo.count(variable_meteo_3))<=Min_meteo: #si le nbr de fois qu'elle est présente est inférieure au minimum, ce nbr de fois devient le minimum

                Min_meteo = int(Meteo.count(variable_meteo_3))

        for compteur in range(0,len(Meteo)): #on parcourt la liste contenant les conditions météo

            variable_meteo_4 = Meteo[compteur] #une autre variable prend successivement la valeur des éléments de la liste

            if Min_meteo == Meteo.count(variable_meteo_4): #si le nbr de fois qu'elle est présente correspondant au minimum c'est gagné, c'est la condition météo la moins rencontrée !

                Meteo_Moins.config(text ="Ce mot te fait peur : "+' '+str(variable_meteo_4.lower())) #Et on conseille le conducteur de la rencontrer plus souvent via un label  #qu'on modifie en conséquence

    #Encore une fois, on traite de la même manière les autres conditions

    # Type trafic ---

        Min_trafic = 1000000

        for i in range (0,len(Trafic)):

            variable_trafic_3 = Trafic[i]

            if int(Trafic.count(variable_trafic_3))<=Min_trafic:

                Min_trafic = int(Trafic.count(variable_trafic_3))

        for compteur in range(0,len(Trafic)):

            variable_trafic_4 = Trafic[compteur]

            if Min_trafic == Trafic.count(variable_trafic_4):

                Trafic_Moins.config(text ="Choissis un trafic plus "+' '+str(variable_trafic_4.lower()))

    # Type route ---

        Min_route = 1000000

        for i in range (0,len(Route)):

            variable_route_3 = Route[i]

            if int(Route.count(variable_route_3))<=Min_route:

                Min_route = int(Route.count(variable_route_3))

        for compteur in range(0,len(Route)):

            variable_route_4 = Route[compteur]

            if Min_route == Route.count(variable_route_4):

                Route_Moins.config(text ="Là où il faudrait que tu conduises davantage : "+' '+str(variable_route_4.lower()))

    # Jour/ Nuit---

    # Traitement différent encore une fois pour la condition jour ou nuit

        Jour = JN.count('De jour\n') #2 variables prennent la valeur du nbr de fois que sont présents jour et nuit

        Nuit = JN.count('De nuit\n')

        if Jour>=Nuit: #si jour est présent plus de fois que nuit, on modifie le label en conséquence et inversement

            JN_Moins.config(text ='Sors donc la nuit !')

        else:

            JN_Moins.config(text ='Sors donc le jour !')

        Conseil.config(text="") #on fait disparaitre le label Conseil qui informait "les conseils arrivent" car en effet, ils sont arrivés ...

# Fonctions des boutons pour les stats

# Vont afficher les graphiques sous forme de camemberts

def Camembert_meteo(): # Statistiques sur la météo

    import numpy as np   # Importer les modules matplotlib, pyplot et numpy permettant la réalisation de graphiques

    import matplotlib.pyplot as plt

    global Meteo  # Récupère la variable meteo du programme principal

    total_meteo= len(Meteo) #Nbr total de données enregistrées pour la météo

    nbr_soleil = int(Meteo.count('Soleil\n'))*(100/total_meteo) #Combien de fois il y a soleil, puis ligne suivant pluie, vent etc.. Remis sur 100 pour les pourcentages

    nbr_pluie = int(Meteo.count('Pluie\n'))*(100/total_meteo)

    nbr_vent = int(Meteo.count('Vent\n'))*(100/total_meteo)

    nbr_neige = int(Meteo.count('Neige\n'))*(100/total_meteo)

    nbr_verglas = int(Meteo.count('Verglas\n'))*(100/total_meteo)

    labels = 'Soleil', 'Pluie', 'Vent', 'Neige', 'Verglas'

    sizes = [nbr_soleil, nbr_pluie, nbr_vent, nbr_neige, nbr_verglas] #on définit les tailles des parties du camembert en fonctions des pourcentages calculés

    colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral','red']

    explode = (0, 0, 0, 0,0) # Pourrait faire ressortir une partie du diagramme, on ne le fait pas ici

    plt.pie(sizes, explode=explode, labels=labels, colors=colors,autopct='%1.1f%%', shadow=True, startangle=90)

# Permet la réalisation du diagramme en camembert, avec les propriétés

    plt.axis('equal') #des proportions égales sur le diagrammes prennent une place identique

    plt.show() #Ouvre le diagramme

# On fait la même chose pour les autres conditions !

def Camembert_trafic():

    import numpy as np

    import matplotlib.pyplot as plt

    global Trafic

    total_trafic= len(Trafic)

    nbr_fluide = int(Trafic.count('Fluide\n'))*(100/total_trafic)

    nbr_assez_fluide = int(Trafic.count('Assez fluide\n'))*(100/total_trafic)

    nbr_assez_dense = int(Trafic.count('Assez dense\n'))*(100/total_trafic)

    nbr_dense = int(Trafic.count('Dense\n'))*(100/total_trafic)

    labels = 'Fluide', 'Assez fluide', 'Assez dense', 'Dense'

    sizes = [nbr_fluide, nbr_assez_fluide, nbr_assez_dense, nbr_dense]

    colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']

    explode = (0, 0, 0, 0)

    plt.pie(sizes, explode=explode, labels=labels, colors=colors,autopct='%1.1f%%', shadow=True, startangle=90)

    plt.axis('equal')

    plt.show()

def Camembert_route():

    import numpy as np

    import matplotlib.pyplot as plt

    global Route

    total_route= len(Route)

    nbr_autoroute = int(Route.count('Autoroute\n'))*(100/total_route)

    nbr_rnrd = int(Route.count('Route nationale/departementale\n'))*(100/total_route)

    nbr_ville = int(Route.count('Ville\n'))*(100/total_route)

    nbr_montagne = int(Route.count('Montagne\n'))*(100/total_route)

    nbr_campagne = int(Route.count('Campagne\n'))*(100/total_route)

    nbr_parking = int(Route.count('Parking\n'))*(100/total_route)

    labels = 'Autoroute', 'Route nationale/departementale', 'Ville', 'Montagne', 'Campagne','Parking'

    sizes = [nbr_autoroute, nbr_rnrd, nbr_ville, nbr_montagne, nbr_campagne,nbr_parking]

    colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral','red','blue']

    explode = (0, 0, 0, 0,0,0)

    plt.pie(sizes, explode=explode, labels=labels, colors=colors,autopct='%1.1f%%', shadow=True, startangle=90)

    plt.axis('equal')

    plt.show()

def Camembert_JN():

    import numpy as np

    import matplotlib.pyplot as plt

    global JN

    total_JN= len(JN)

    nbr_jour = int(JN.count('De jour\n'))*(100/total_JN)

    nbr_nuit = int(JN.count('De nuit\n'))*(100/total_JN)

    labels = 'Jour', 'Nuit'

    sizes = [nbr_jour, nbr_nuit]

    colors = ['lightskyblue', 'lightcoral']

    explode = (0, 0)

    plt.pie(sizes, explode=explode, labels=labels, colors=colors,autopct='%1.1f%%', shadow=True, startangle=90)

    plt.axis('equal')

    plt.show()

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

# INTERFACE GRAPHIQUE

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

# Fenêtre principale

Fenetre= Tk() #création de la fenêtre

Fenetre.title('La Conduite Intelligente et Accompagnée') #titre

Fenetre.geometry('1260x700') #et de ses mesures

# Bouton enregistrer

Enregistrer = Button(Fenetre, width =30, height =3, relief='groove', text='Enregistrer', command = Donnees) # ce bouton lance la fonction principale "donnees"

Enregistrer.place(x=200, y=610)

# Bouton quitter

Bouton_quitter = Button(Fenetre, width=12,text='Fermer', command=Fonction_quitter) #bouton quitter qui ferme la fenetre

Bouton_quitter.place(x=560,y=650)

# Boutons permettant d'afficher les graphiques camemberts (on les décore d'une image)

image_meteo = ImageTk.PhotoImage(file='meteo2test.gif') #Récupère l'image dans le dossier où se trouve le fichier python

Bouton_stat_meteo = Button(Fenetre,width=55,height=35,relief='groove', image=image_meteo, command= Camembert_meteo) # Création du bouton avec l'image dessus et qui lance la fonction qui crée le diagramme quand on clique dessus

Bouton_stat_meteo.place(x=880,y=260)

image_meteo_label= Label(Fenetre,text='Météo') # Texte à afficher en dessous

image_meteo_label.place(x=890,y=300)

# On fait de même pour les autres boutons

image_trafic = ImageTk.PhotoImage(file='trafic-image.gif')

Bouton_stat_trafic = Button(Fenetre,width=55,height=35,relief='groove',image=image_trafic, command= Camembert_trafic)

Bouton_stat_trafic.place(x=945,y=260)

image_trafic_label= Label(Fenetre,text='Trafic')

image_trafic_label.place(x=952,y=300)

image_typeroute = ImageTk.PhotoImage(file='image-route.gif')

Bouton_stat_type = Button(Fenetre,width=83,height=35,relief='groove',image=image_typeroute, command=Camembert_route)

Bouton_stat_type.place(x=1010,y=260)

image_type_label= Label(Fenetre,text='Type de route')

image_type_label.place(x=1014,y=300)

image_regularite = ImageTk.PhotoImage(file='graphique.gif')

Bouton_stat_regularite = Button(Fenetre,width=55,height=35,relief='groove',image=image_regularite, command= Camembert_JN)

Bouton_stat_regularite.place(x=1105,y=260)

image_regularite_label= Label(Fenetre,text='Jour/Nuit')

image_regularite_label.place(x=1108,y=300)

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

# Formulaire questions

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

Demande_nbr_km = Label(Fenetre,text='Combien de kilomètres as-tu parcouru ?') # pose la question à l'utilisateur

Demande_nbr_km.place(x=40,y=200)

Nbr_km =Entry(width=15) #création de l'espace où on demande le nbr de km    :   il peut ici répondre à la question posée plus haut

Nbr_km.place(x=40,y=225)

km= Label(Fenetre,text='kilomètres')

km.place(x=155,y=225)

Demande_date = Label(Fenetre,text='Quel jour était-ce ?') # question à propos de la date

Demande_date.place(x=40,y=260)

date_01 =Entry(width=15) # réponse à propos de la date

date_01.place(x=40,y=285)

dat= Label(Fenetre,text='AAAA/MM/JJ')

dat.place(x=155,y=285)

demande_meteo = Label(Fenetre,text='Quelle était la condition météorologique ?')

demande_meteo.place(x=40,y=320)

demande_trafic = Label(Fenetre,text='Quelle était la condition de circulation ? (trafic)')

demande_trafic.place(x=40,y=405)

demande_route = Label(Fenetre,text='Sur quel type de route as-tu conduit majoritairement ?')

demande_route.place(x=40,y=490)

demande_jour_nuit = Label(Fenetre,text='As-tu conduit :')

demande_jour_nuit.place(x=40,y=575)

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

# Partie information

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

km_parcourus= Label(Fenetre,text='') #Ici est le label où sera écrit le nombre de kilomètres après avoir cliquer sur enregistrer

km_parcourus.place(x=480,y=210)

Today = Label(Fenetre, text='Nous sommes le :' + ' ' +str(date.today())) #on récupère la date d'aujourd'hui pour la faire afficher, histoire que l'apprenti l'ait sous les yeux !

Today.place(x=480,y=240)

Meteo_Plus = Label(Fenetre, text="Ici va s'afficher ta condition météorologique préférée !")

Meteo_Plus.place(x=480,y=270)

Trafic_Plus = Label(Fenetre, text ="Quel type de trafic te colle à la peau ?")

Trafic_Plus.place(x=480,y=300)

Route_Plus = Label(Fenetre, text ="Mais quel est ton type de route préférée ? ")

Route_Plus.place(x=480,y=330)

JN_Plus = Label(Fenetre, text ="Plutôt nuit ou jour ? ")

JN_Plus.place(x=480,y=360)

Temps_utilise = Label(Fenetre)

Temps_utilise.place(x=480,y=390)

Temps_restant = Label(Fenetre)

Temps_restant.place(x=480,y=420)

# ########

# Conseils

# ########

Conseil = Label(Fenetre, text = "Les conseils arrivent ! ")

Conseil.place(x=860, y=430)

Route_Moins = Label(Fenetre, text =" ")

Route_Moins.place(x=860,y=460)

Meteo_Moins = Label(Fenetre, text="")

Meteo_Moins.place(x=860,y=490)

Trafic_Moins = Label(Fenetre, text ="")

Trafic_Moins.place(x=860,y=520)

JN_Moins = Label(Fenetre, text =" ")

JN_Moins.place(x=860,y=550)

Comparaison_moyenne = Label(Fenetre, text="")

Comparaison_moyenne.place(x=860,y=580)

# Canevas Logo

# déclaration de la zone Canvas

Mon_canvas = Canvas(Fenetre)

# on met le fichier "Logo.jpg" dans l'objet que j'appelle "im"

im = Image.open("Logo.jpg")

# cet objet (contenant le fichier image) est mis dans un objet Tkinter que j'appelle "photo"

photo = ImageTk.PhotoImage(im)

# coordonnées du Canvas

X_Canvas=80

Y_Canvas=10

# on met l'image "photo" dans le canvas

Mon_canvas.create_image(0,0,image=photo, anchor=NW)

# on fixe largeur et longueur du canvas en fonction des dimension de l'image.

Mon_canvas.config(width = im.size[0]+X_Canvas, height = im.size[1]+Y_Canvas)

# on affiche le canvas

Mon_canvas.place(x=X_Canvas,y=Y_Canvas)

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

# Images des titres

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

Mon_canvas_titre = Canvas(Fenetre) # même principe que pour l'image au dessus

im_titre = Image.open("titre.jpg")

photo_titre = ImageTk.PhotoImage(im_titre)

X_Canvas_titre=295

Y_Canvas_titre=52

Mon_canvas_titre.create_image(0,0,image=photo_titre, anchor=NW)

Mon_canvas_titre.config(width = im_titre.size[0]+X_Canvas_titre, height = im_titre.size[1]+Y_Canvas_titre-30) # On règle ici la taille du canvas par rapport à l'image

Mon_canvas_titre.place(x=X_Canvas_titre,y=Y_Canvas_titre)

Mon_canvas_form = Canvas(Fenetre)

im_form = Image.open("formulaire.jpg")

photo_form = ImageTk.PhotoImage(im_form)

X_Canvas_form=40

Y_Canvas_form=150

Mon_canvas_form.create_image(0,0,image=photo_form, anchor=NW)

Mon_canvas_form.config(width = im_form.size[0]+X_Canvas_form, height = im_form.size[1]+Y_Canvas_form-140)

Mon_canvas_form.place(x=X_Canvas_form,y=Y_Canvas_form)

Mon_canvas_info = Canvas(Fenetre)

im_info = Image.open("informations.jpg")

photo_info = ImageTk.PhotoImage(im_info)

X_Canvas_info=460

Y_Canvas_info=150

Mon_canvas_info.create_image(0,0,image=photo_info, anchor=NW)

Mon_canvas_info.config(width = im_info.size[0]+X_Canvas_info, height = im_info.size[1]+Y_Canvas_info-140)

Mon_canvas_info.place(x=X_Canvas_info,y=Y_Canvas_info)

Mon_canvas_stat = Canvas(Fenetre)

im_stat = Image.open("stats.jpg")

photo_stat = ImageTk.PhotoImage(im_stat)

X_Canvas_stat=875

Y_Canvas_stat=145

Mon_canvas_stat.create_image(0,0,image=photo_stat, anchor=NW)

Mon_canvas_stat.config(width = im_stat.size[0]+X_Canvas_stat, height = im_stat.size[1]+Y_Canvas_stat-140)

Mon_canvas_stat.place(x=X_Canvas_stat,y=Y_Canvas_stat)

Mon_canvas_conseils = Canvas(Fenetre)

im_conseils = Image.open("conseils.jpg")

photo_conseils = ImageTk.PhotoImage(im_conseils)

X_Canvas_conseils=890

Y_Canvas_conseils=375

Mon_canvas_conseils.create_image(0,0,image=photo_conseils, anchor=NW)

Mon_canvas_conseils.config(width = im_conseils.size[0]+X_Canvas_conseils, height = im_conseils.size[1]+Y_Canvas_conseils-360)

Mon_canvas_conseils.place(x=X_Canvas_conseils,y=Y_Canvas_conseils)

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

# Les cases à cocher

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

# METEO

# Utilisation de boutons-radios (Une seule case peut être cochée)

variablemeteo = StringVar() # module de tkinter : variable sous forme de série

i_meteo=0 # va permettre de placer les réponses les unes par rapport aux autres

for item in ['Soleil', 'Pluie', 'Vent', 'Neige', 'Verglas']: # On donne ici les différentes réponses possibles à cocher que l'on parcourt

    rbmeteo = Radiobutton(Fenetre, text=item,value=item,variable=variablemeteo) # On les met sous forme de radioboutons (ils sont textes + valeurs)

    rbmeteo.pack() # on les rassemble

    rbmeteo.place(x=40+i_meteo,y=345) # on les place

    i_meteo=i_meteo+70 #on incrémente la variable i_meteo

# TRAFIC

# on utilisera le même système pour le trafic, la route etc

variabletrafic = StringVar()

i_trafic=0

for item in ['Fluide', 'Assez fluide', 'Assez dense','Dense']:

    rbtrafic = Radiobutton(Fenetre, text=item,value=item,variable=variabletrafic)

    rbtrafic.pack()

    rbtrafic.place(x=40+i_trafic,y=430)

    i_trafic=i_trafic+90

# TYPE DE ROUTE

variabletypederoute = StringVar()

i_typederoute=0

for item in ['Autoroute', 'Parking', 'Ville','Montagne', 'Campagne','Route nationale/departementale']:

    rbtypederoute = Radiobutton(Fenetre, text=item,value=item,variable=variabletypederoute)

    rbtypederoute.pack()

    rbtypederoute.place(x=40+i_typederoute,y=515)

    i_typederoute=i_typederoute+85

# JOUR OU NUIT

variablejour_nuit = StringVar()

i_jour_nuit=0

for item in ['De jour', 'De nuit']:

    rbjour_nuit = Radiobutton(Fenetre, text=item,value=item,variable=variablejour_nuit)

    rbjour_nuit.pack()

    rbjour_nuit.place(x=40+i_jour_nuit,y=595)

    i_jour_nuit=i_jour_nuit+70

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

# Programme  principal

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

Fenetre.mainloop() #permet d'ouvrir et afficher la fenêtre