Projet Bac ISN 2014 Diane et Océane

Projet_diane_oceane

En cliquant sur ce lien vous allez télécharger tout ce qui est nécessaire pour que notre programme fonctionne.

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

• Avancé à la maison :

Diane : Conseils et partie information presque finis

Océane : Camemberts graphiques réalisés

• Séance ISN :

Bug programme de Diane au niveau comptage de km, et impossible d'afficher les graphiques -> Bug clé USB Diane ?  REUSSI

Diane & Océane : Gestion des bugs d'affichage des conseils et infos, ainsi que bug conseil jour/nuit ...

Bugs réglés, plus de problème pour les infos/conseils

- Rassemblage des deux parties, ca maaaaaaaaaaaaarche !

• A faire/penser/réfléchir..  :

Interface graphique : Déplacer les conseils en bas à drote,DIANE

Déplacer (et agrandir?) les boutons stats (en colonne?), OCEANE

Faire les images jolies pour les Labels ( Titres etc..) DIANE&OCEANE

Temps : Récupérer la première date DIANE

Conseil de la gestion du temps DIANE

(si on arrive pas avec les dates, enlever l'entry de la date..?) DIANE

Boutons radios : Faire en sorte qu'ils soient non cochés dès le départ (ou un seul) OCEANE

Gestion des erreurs : - Si on entre pas des nombres dans le nombre de km et de la date = afficher un message box OCEANE

Blog : Refaire un planning.. OCEANE

Messagebox infos :  http://www.tutorialspoint.com/python/tk_messagebox.htm

Pour nous : http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.bar

http://matplotlib.org/users/screenshots.html

http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.pie

DIANE : - Gestion du temps : réussi à faire afficher la date

- Gestion des informations avancée

OCEANE : - Fini les graphiques... mais décision de faire des diagrammes en camembert 

- commencé à faire les statistiques (réussi) 

DIANE :

- Gestion des fichiers finalisée, toutes les informations sont maintenant mises sous forme de listes séparées (une pour les km, une pour les conditions météos ...)

- Affichage du nb de km total ok

- Rassemblement travail Océ avec travail Diane

- Recherche notion de temps et dates

OCEANE :

- Boutons radios OK, réussi à récupérer leurs valeurs

- Essais sur les stats avec Pylab mais PROBLEME => Pylab très lent et semble incompatible avec widgets Tkinter ...

- Recherche sur ce bug, +recherche d'autres solutions pour les graphiques

Décision : On ne pourra cocher qu'une seule case par question afin de faciliter la gestion des fichiers et les graphiques (trop dur sinon)

Pour la gestion de la date :

http://www.developpez.net/forums/d1373263/autres-langages/python-zope/statistique-python/

Pour les graphiques :

http://www.courspython.com/v3/intro_pylab.html      --------> Utilisation de PYLAB

http://www-irma.u-strasbg.fr/~sonnen/numpy-quickref_fr.pdf

Pour les radioboutons :

http://www.fil.univ-lille1.fr/~marvie/python/chapitre6.html

OCEANE : - Recherche sur les graphiques : ait décidé l'utilisation de Pylab (fait partie de matplotlib)

Essai de faire un premier graphique ("essai_graphique_pylab" dans le dossier projet_bac de la clé). Réussi. A faire et à chercher : comment rendre x et y (abs et ord) variables (augmente à chaque fois que la case a été cochée) ?

Les graphiques seront de la forme : Le type de météo en fonction du nombre de fois que ce type a été coché. Que le y qui varie alors

Comment récupérer le y ? -----------> Fichier qui va être récupéré de Diane du type "Vent Vent Pluie Soleil Vent" ; récupérer ensuite grâce à ".count(Element)" le nombre de fois qu'il est présent et ce nombre définit le y.

DIANE :  Toujours Gestion des Fichiers :

-réussi à faire des blocs de 6 au lieu de 19 ( une info par question ) 

-essayé de mettre les informations sous forme de listes ( une liste pour chaque question ) CA MARCHE PAS

Bilan de la séance :

DIANE : Gestion des fichiers : pour l'instant abandon de l'idée d'utiliser une base de données. Choix de la gestion de fichiers

Réussi à créer un fichier et à récupérer les données remplies dans le formulaire par l'utilisateur.

OCEANE : Rassemnlage des interfaces, réussi sauf les images et de destroy la fenêtre "Creation" quand la fenêtre principale s'ouvre

PROBLEME A CHERCHER : comment rendre global une fenêtre dans une fonction ?

POUR LA SUITE : - Dièser toutes les parties interfaces de Diane dans le programme pour se concentrer sur la gestion de fichiers. Comment récupérer les données que Diane a mises dans le fichier pour faire les graphiques ?

- Pour le questionnaire du formulaire : mettre "qu'avez vous fait Principalement" et utiliser des boutons radio (PLUS SIMPLE) OU pas ?

- Essai du rassemblement des deux interfaces graphiques

- Etude du calendrier (presque réussi)

- Essai base de données : Gadfly, Firebird, MySQL et de gestion de fichiers avec JSON et XML SANS SUCCES

- Gestion de fichiers "brut" qui ne marche pas

- Réussite pour mettre des images dans l'interface graphique et des cases de cochage

Diane :

-> Problème concernant les utilisateurs = Un seul utilisateur ou plusieurs ?

Nous avons opté pour plusieurs utilisateurs, et donc mise en place d'une interface graphique initiale pour savoir si l'utilisateur existe déjà ou non. Si il n'existe pas, créer un ficher et si il existe ouvrir son profil.

Océane :

-> Interface graphique principale

-> Gros problème pour insérer une image ...

- 19/02 : comment faires de cochages = résolu ! Finition de l'interface graphique au niveau du formulaire (penser a ajouter ".get()" aux entry "combien de km" et "quelle date" quand il y en aura besoin

insertion du logo réussie dans la fenêtre principale de l'application

MAIS PAS RÉUSSI A INSERER LE LOGO DANS CELLE DE DIANE ( à deboguer )

---> réussi

- 21/02 : finition des boutons statistiques au niveau esthétique : ajout d'une image sur chaque bouton ! 

C.I.A : Conduite Intelligente et Accompagnée