#! /usr/bin/python ## apoglide ## ========= ## Objectif initial : Analyse des treuillees de planeur a partir ## ---------------- des enregistrements GPS des vols ## Copyright (C) Marc Archambault ## ## This program is free software; you can redistribute it and/or ## modify it under the terms of the GNU General Public License ## as published by the Free Software Foundation; either version 2 ## of the License, or (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, write to the Free Software ## Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. import Tkinter import Pmw import math import os try : from tkFileDialog import askopenfilename except ImportError , libelle : print "tkFileDialog non installe " print " ( Fichier/Ouvrir limite au dossier ~/apoglide/enregistrements GPS)" print "tkFileDialog not available" print " ( File/Open limited to folder ~/apoglide/enregistrements GPS)" #####=====#####=====#####=====#####=====#####=====#####=====#####=====##### #####=================================================================##### ##### F O N C T I O N S ##### #####=================================================================##### #####=====#####=====#####=====#####=====#####=====#####=====#####=====##### ############################################################################### def extco ( listeLignesFichier ) : # ############################################################################### """ A partir d'une liste (fichier IGC : enregistrement d'un vol de planeur) la fonction renvoie une liste des lignes de coordonees ( les autres lignes ne sont pas renvoyees ) """ # initialisation listeLignesCoordonees = [] # parcours des lignes for ligne in listeLignesFichier : if ligne[0] == 'B' or ligne[0] == 'b' : listeLignesCoordonees.append(ligne) # repondre return listeLignesCoordonees ############################################################################### def decortili ( ligneIGC ) : # ############################################################################### """ ligne recue : B1230284709789N00256754EA0014200190 ligne retournee : [47.16315 , -2.9459 , 142.0 , 12.0 , 30.0 , 28.0 ] [latitude ,longitude, alti(m), heure , minute , sec ]""" # initialisation lat , lon , alti , heure , minute , sec = 0,0,0,0,0,0 # mise en forme if ligneIGC[0] == 'B' or ligneIGC[0] == 'b' : heure = float(ligneIGC[1:3]) minute = float(ligneIGC[3:5]) sec = float(ligneIGC[5:7]) lat = float(ligneIGC[7:9]) + \ float(ligneIGC[9:11]) / 60 + \ float(ligneIGC[11:14])/60000 if ligneIGC[14] == 'N' or ligneIGC[14] == 'n' : pass else : lat = -lat lon = float(ligneIGC[15:18]) + \ float(ligneIGC[18:20]) / 60 + \ float(ligneIGC[20:23])/60000 if ligneIGC[23] == 'E' or ligneIGC[23] == 'e' : lon = -lon if ligneIGC[24] == 'A' or ligneIGC[24] == 'a' : alti = float(ligneIGC[25:30]) # repondre return [ lat , lon , alti , heure , minute , sec ] ############################################################################### def projPtMA ( point , centre , orientationGeo , oblicite , echelle , anamorphismeVertical ) : ############################################################################### """ calcule les coordonees d'un point dans un repere centre sur le point designe comme centre. - Z est la verticale locale - La projection est de type_ 'Mercator' (sphere -> plan) ( latitude et longitude forment un reseau carre ) - Cette projection est orientee dans son propre plan - l'unite d'orientation est le degre (et ses decimales) - l'origine de l'orientation est l'axe des abscices (soit Nord vers la droite) - le sens d'orientation correspond au sens trigonometrique - Exemple : orientationGeo = 90 ==> Nord en haut - L'axe Z est anamorphose (echelle differente) - A cela s'ajoute une rotation autour de l'axe x d'un angle nome oblicite Formats : - point [ longitude(deg) , lattitude(deg) , altitude(m) ] - centre [ longitude(deg) , lattitude(deg) , altitude(m) ] - orientationGeo (deg) - oblicite (deg) - echelle (nombre reel positif non nul) - anamorphismeVertical (nombre reel positif )""" # mise en forme des donnees orientationGeo = float(orientationGeo ) oblicite = float(oblicite ) echelle = float(echelle ) anamorphismeVertical = float(anamorphismeVertical) # projection Mercator x1 = float( ( point[0] - centre[0] ) * 1852 * 60 ) y1 = float( math.cos(centre[0]*math.pi/180) * \ (point[1]-centre[1]) * 1852 * 60 ) z1 = float( point[2] - centre[2] ) #print 'x1,y1,z1 = ', x1 , y1 , z1 # echelle x1,y1,z1 = x1*echelle , y1*echelle , z1*echelle # anamorphisme z1 = z1 * anamorphismeVertical # orientation x2 = x1 * math.cos(orientationGeo*math.pi/180) + \ y1 * math.sin(orientationGeo*math.pi/180) y2 = y1 * math.cos(orientationGeo*math.pi/180) - \ x1 * math.sin(orientationGeo*math.pi/180) z2 = z1 # oblicite x3 = x2 y3 = y2 * math.cos(-oblicite*math.pi/180) + \ z2 * math.sin(-oblicite*math.pi/180) z3 = z2 * math.cos(-oblicite*math.pi/180) - \ y2 * math.sin(-oblicite*math.pi/180) return [ x3 , y3 , z3 ] ############################################################################### def limiterVol ( PtsVol , centre , rayon , hauteur ) : # ############################################################################### """ limite le vol a la phase de lance """ # limiter le vol dans un cylindre autour du centre de l aerodrome volLimite , sit = [] , 0 for p in PtsVol : d = 1852.0 * 60.0 * ( ((centre[0]-p[0])**2 + \ (math.cos(centre[0]*math.pi/180)*(centre[1]-p[1]))**2)**0.5 ) if d <= rayon and p[2] < centre[2]+hauteur : if sit == 0 : sit = 1 volLimite.append ( p ) else : if sit == 1 : break # supprimer les points du debut , avant le decollage # (3 pts successifs meme position meme altitude) volLimite1 , sit1 , n = [] , 0 , 0 try : pm2 , pm1 = volLimite[0] , volLimite[1] except IndexError , libelle : pm2 , pm1 = [0,0,0,0,0] , [0,0,0,0,0] else : pass for p in volLimite [2:] : if p[0]==pm1[0] and p[1]==pm1[1] and p[2]==pm1[2] and \ p[0]==pm2[0] and p[1]==pm2[1] and p[2]==pm2[2] : pass else : volLimite1 = volLimite [n:] d2 = 1852.0 * 60.0 * ( ((p[0]-pm2[0])**2 + \ (math.cos(centre[0]*math.pi/180)*(p[1]-pm2[1]))**2)**0.5 ) t2 = (p[3]-pm2[3])*3600 + (p[4]-pm2[4])*60 + (p[5]-pm2[5]) v2 = d2 / t2 d1 = 1852.0 * 60.0 * ( ((p[0]-pm1[0])**2 + \ (math.cos(centre[0]*math.pi/180)*(p[1]-pm1[1]))**2)**0.5 ) t1 = (p[3]-pm1[3])*3600 + (p[4]-pm1[4])*60 + (p[5]-pm1[5]) v1 = d1 / t1 if v1 > 5 and v2 > 5 and v1 > 0.8*v2 and v2 > 0.8*v1 : break pm2 , pm1 , n = pm1 , p , n + 1 # supprimer les points apres le larguage , vario negatif try : pm5 , pm4 , pm3 , pm2 , pm1 = volLimite1[0] , volLimite1[1] , \ volLimite1[2] , volLimite1[3] , volLimite1[4] except IndexError , libelle : pm5 , pm4 , pm3 , pm2 , pm1 = \ [0,0,0,0,0] , [0,0,0,0,0] , [0,0,0,0,0] , [0,0,0,0,0] , [0,0,0,0,0] volLimite2 = [ pm5 , pm4 , pm3 , pm2 , pm1 ] for p in volLimite1 [5:] : if p[2] < pm1[2] and pm1[2] < pm2[2] and pm2[2] < pm3[2] and \ pm3[2] < pm4[2] and pm4[2] < pm5[2] : break else : volLimite2.append(p) pm5 , pm4 , pm3 , pm2 , pm1 = pm4 , pm3 , pm2 , pm1 , p # eviter de creer une fausse liste if volLimite2 == [ [0,0,0,0,0] , [0,0,0,0,0] , [0,0,0,0,0] , [0,0,0,0,0] ,\ [0,0,0,0,0] ] : volLimite2 = [] # repondre return volLimite2 ############################################################################### def faireLaListeToutesInfosTousAerodromes ( cheminHome ) : # ############################################################################### """ Objectif : recuperer toutes les infos sur tous les aerodromes connus par le logiciel Donnee recue : 'cheminHome' = '/home/utilisateur/' Donnees retournees : [ [listeToutesInfoAero1],[listeToutesInfoAero2],...] listeToutesInfoAeroN = [ nom , pays , pistes , contours , treuils , pistesSecondaireOuAvion , pistesAncienne , taxiwayPlaneur , taxiwaySecondaireOuAvion ]""" # Initialisation listeToutesInfosTousAerodromes = [] # faire la liste des fichiers d'aerodromes os.chdir ( cheminHome ) # traiter le contennu du dossier 'apoglide/aerodromes/' listeFichiersAerodromes = [] try : os.chdir ( 'apoglide/aerodromes/' ) except OSError , libelle : print 'pas de dossier aerodrome' else : listeFichiersAerodromes2 = os.listdir( '.' ) for i in listeFichiersAerodromes2 : if i[0] != '.' and i[-1] != '~' : listeFichiersAerodromes.append(i) listeFichiersAerodromes.sort() # lire les fichiers d'aerodromes for i in listeFichiersAerodromes : listeDesInfoDeLaerodrome = faireLaListeDesInfosDeLaerodrome(i) listeToutesInfosTousAerodromes.append( listeDesInfoDeLaerodrome ) os.chdir ( '../..' ) # traiter le contennu du dossier 'apoglide/airfields/' listeFichiersAerodromes = [] try : os.chdir ( 'apoglide/airfields/' ) except OSError , libelle : print 'pas de dossier airfields' else : listeFichiersAerodromes2 = os.listdir( '.' ) for i in listeFichiersAerodromes2 : if i[0] != '.' and i[-1] != '~' : listeFichiersAerodromes.append(i) listeFichiersAerodromes.sort() # lire les fichiers d'aerodromes for i in listeFichiersAerodromes : listeDesInfoDeLaerodrome = faireLaListeDesInfosDeLaerodrome(i) listeToutesInfosTousAerodromes.append( listeDesInfoDeLaerodrome ) os.chdir ( '../..' ) # traiter le contennu du dossier 'apoglide/flugplatz/' listeFichiersAerodromes = [] try : os.chdir ( 'apoglide/flugplatz/' ) except OSError , libelle : print 'pas de dossier flugplatz' else : listeFichiersAerodromes2 = os.listdir( '.' ) for i in listeFichiersAerodromes2 : if i[0] != '.' and i[-1] != '~' : listeFichiersAerodromes.append(i) listeFichiersAerodromes.sort() # lire les fichiers d'aerodromes for i in listeFichiersAerodromes : listeDesInfoDeLaerodrome = faireLaListeDesInfosDeLaerodrome(i) listeToutesInfosTousAerodromes.append( listeDesInfoDeLaerodrome ) os.chdir ( '../..' ) return listeToutesInfosTousAerodromes ############################################################################### def faireLaListeDesInfosDeLaerodrome ( nomFichierAero ) : # ############################################################################### """ Fonction utile a la fonction : faireLaListeToutesInfosTousAerodromes """ # initialisation listeDesInfosDeLaerodrome = [] format_aero , nom , pays = '' , '' , '' contours , pistes , treuils = [],[],[] pistesAvion , pistesAnciennePlaneur , pistesModelisme = [],[],[] taxiwayPlaneur , taxiwayAvion = [] , [] f = open ( nomFichierAero , 'r' ) fichier = f.readlines() f.close() #infoAerodrome = decortiquerFichierAerodrome(fichier) for l in fichier : if l[0] == '#' : pass elif l[0:11] == 'format_aero' : for c in l[12:] : if c == ',' : break format_aero = format_aero + c elif l[0:3] == 'nom' : for c in l[4:] : if c == ',' : break nom = nom + c elif l[0:4] == 'pays' : for c in l[5:] : if c == ',' : break pays = pays + c elif l[0:12] == 'pistePlaneur' : infoPiste = faireLaListeDesInfosDunePiste ( l[13:] ) if infoPiste != [] : pistes.append( infoPiste ) elif l[0:10] == 'pisteMixte' : infoPiste = faireLaListeDesInfosDunePiste ( l[11:] ) if infoPiste != [] : pistes.append( infoPiste ) elif l[0:7] == 'contour' : points , latitude , longitude , altitude , a = [] , 0 , 0 , 0 , '' for c in l[8:] : if c == ',' and latitude == 0 : latitude , a = float(a) ,'' elif c == ',' and longitude == 0 : longitude , a = float(a) ,'' elif c == ',' and altitude == 0 : altitude , a = float(a) , '' if [latitude,longitude,altitude] != [ 0 , 0 , 0 ] : points.append([latitude,longitude,altitude]) latitude , longitude , altitude = 0 , 0 , 0 else : a = a+c if points != [] : contours.append( [ points ] ) elif l[0:22] == 'treuil' : nomPiste,point,latitude,longitude,altitude,a = '',[],0,0,0,'' for c in l[23:] : if c == ',' and nomPiste == '' : nomPiste , a = a ,'' elif c == ',' and latitude == 0 : latitude , a = float(a) ,'' elif c == ',' and longitude == 0 : longitude , a = float(a) ,'' elif c == ',' and altitude == 0 : altitude , a = float(a) , '' if [latitude,longitude,altitude] != [ 0 , 0 , 0 ] : point.append([latitude,longitude,altitude]) latitude , longitude , altitude = 0 , 0 , 0 else : a = a+c if points != [] : treuils.append( [ nomPiste , point ] ) elif l[0:10] == 'pisteAvion' : infoPiste = faireLaListeDesInfosDunePiste ( l[11:] ) if infoPiste != [] : pistesAvion.append( infoPiste ) elif l[0:20] == 'pisteAnciennePlaneur' : infoPiste = faireLaListeDesInfosDunePiste ( l[21:] ) if infoPiste != [] : pistesAnciennePlaneur.append( infoPiste ) elif l[0:18] == 'pisteAncienneMixte' : infoPiste = faireLaListeDesInfosDunePiste ( l[19:] ) if infoPiste != [] : pistesAnciennePlaneur.append( infoPiste ) elif l[0:14] == 'pisteModelisme' : infoPiste = faireLaListeDesInfosDunePiste ( l[15:] ) if infoPiste != [] : pistesModelisme.append( infoPiste ) elif l[0:14] == 'taxiwayPlaneur' : infoTaxiway = faireLaListeDesInfosDunTaxiway ( l[15:] ) if infoTaxiway != [] : taxiwayPlaneur.append ( infoTaxiway ) elif l[0:12] == 'taxiwayAvion' : infoTaxiway = faireLaListeDesInfosDunTaxiway ( l[13:] ) if infoTaxiway != [] : taxiwayAvion.append(infoTaxiway) listeDesInfosDeLaerodrome = [ format_aero , nom , pays , pistes , contours , treuils , pistesAvion , pistesAnciennePlaneur , pistesModelisme , taxiwayPlaneur , taxiwayAvion ] return listeDesInfosDeLaerodrome ############################################################################### def faireLaListeDesInfosDunePiste ( partieUtileLignePiste ) : # ############################################################################### """ Fonction utile a la fonction : faireLaListeDesInfosDeLaerodrome """ # initialisation nomPiste , surface , nomPisteOpposee , cap , points = '' , '' , '' , '' ,[] latitude , longitude , altitude , a = 0 , 0 , 0 , '' # recuperation des informations for c in partieUtileLignePiste : if c==',' and nomPiste == '' : nomPiste ,a = a ,'' elif c==',' and surface == '' : surface ,a = a ,'' elif c==',' and nomPisteOpposee == '' : nomPisteOpposee,a = a ,'' elif c==',' and cap == '' : cap ,a = float(a),'' elif c==',' and latitude == 0 : latitude ,a = float(a),'' elif c==',' and longitude == 0 : longitude ,a = float(a),'' elif c==',' and altitude == 0 : altitude , a = float(a) , '' if [latitude,longitude,altitude] != [ 0 , 0 , 0 ] : points.append([latitude,longitude,altitude]) latitude , longitude , altitude = 0 , 0 , 0 else : a = a+c # repondre if points != [] : return [ nomPiste , surface , nomPisteOpposee , cap , points ] else : return [] ############################################################################### def faireLaListeDesInfosDunTaxiway ( partieUtileLigneTaxiway ) : # ############################################################################### """ Fonction utile a la fonction : faireLaListeDesInfosDeLaerodrome """ # initialisation surface , points , latitude , longitude , altitude , a = '',[],0,0,0,'' for c in partieUtileLigneTaxiway : if c == ',' and surface == '' : surface , a = a , '' elif c == ',' and latitude == 0 : latitude , a = float(a) , '' elif c == ',' and longitude == 0 : longitude , a = float(a) , '' elif c == ',' and altitude == 0 : altitude , a = float(a) , '' if [latitude,longitude,altitude] != [ 0 , 0 , 0 ] : points.append([latitude,longitude,altitude]) latitude , longitude , altitude = 0 , 0 , 0 else : a = a+c if points != [] : return [ surface , points ] else : return [] ############################################################################### def recupererPreferences ( cheminHome , cheminPreferences ) : # ############################################################################### """ Fonction qui lit les preferences de demarrage de apoglide """ # lire le fichier os.chdir ( cheminHome ) os.chdir ( cheminPreferences ) f = open ( 'preferences.txt' , 'r' ) fichierPreferences = f.readlines() f.close() # extraire les donnees listePreferences , a = [] , '' langageD , formatPrefD = '' , '' xGrapheD,yGrapheD,couleurFondD,echelleD,anamorphismeD,obliciteD = \ '','','','','','' aerodromeD,nomPisteChoisieD = '','' dessinerTrianglePisteD,ecrireNomPisteD,dessinerVecteur100mD = '','','' annotationGeneVolPrincipalD,annotationInterVolPrincipalD, \ pasAnnotInterVolPrincipalD = '','','' for ligne in fichierPreferences : a = '' if ligne[0] == '#' : pass elif ligne[0: 18] == 'format_preferences' : for c in ligne[ 19:] : if c == ',' : formatPrefD , a = a , '' break else : a = a+c elif ligne[0: 7] == 'langage' : for c in ligne[ 8:] : if c == ',' : langageD , a = a , '' break else : a = a+c elif ligne[0:18] == 'largueur du graphe' : for c in ligne[19:] : if c == ',' : xGrapheD , a = a , '' break else : a = a+c elif ligne[0:17] == 'hauteur du graphe' : for c in ligne[18:] : if c == ',' : yGrapheD , a = a , '' break else : a = a+c elif ligne[0:15] == 'echelle (pix/m)' : for c in ligne[16:] : if c == ',' : echelleD , a = a , '' break else : a = a+c elif ligne[0:34] == 'coeficient d anamorphisme vertical' : for c in ligne[35:] : if c == ',' : anamorphismeD , a = a , '' break else : a = a+c elif ligne[0:17] == 'oblicite initiale' : for c in ligne[18:] : if c == ',' : obliciteD , a = a , '' break else : a = a+c elif ligne[0:31] == 'dessiner triangle de sens piste' : for c in ligne[32:] : if c == ',' : dessinerTrianglePisteD , a = a , '' break else : a = a+c elif ligne[0:16] == 'ecrire nom piste' : for c in ligne[17:] : if c == ',' : ecrireNomPisteD , a = a , '' break else : a = a+c elif ligne[0:31] == 'dessiner vecteur vertical 100 m' : for c in ligne[32:] : if c == ',' : dessinerVecteur100mD , a = a , '' break else : a = a+c elif ligne[0:17] == 'aerodrome initial' : for c in ligne[18:] : if c == ',' : aerodromeD , a = a , '' break else : a = a+c elif ligne[0:14] == 'piste initiale' : for c in ligne[15:] : if c == ',' : nomPisteChoisieD , a = a , '' break else : a = a+c elif ligne[0:36] == 'annotation generale du vol principal' : for c in ligne[37:] : if c == ',' : annotationGeneVolPrincipalD , a = a , '' break else : a = a+c elif ligne[0:41] == 'annotation intermediaire du vol principal' : for c in ligne[42:] : if c == ',' : annotationInterVolPrincipalD , a = a , '' break else : a = a+c elif ligne[0:30] == 'pas d annotation intermediaire' : for c in ligne[31:] : if c == ',' : pasAnnotInterVolPrincipalD , a = a , '' break else : a = a+c # donner une valeur acceptable aux variables si besoin if formatPrefD == '' : print "Echec -format des preferences non detecte" print " -preferences format not find" if langageD == '' : langageD = 'en' print "Echec -language interface graphique" print " -langage graphic interface" if xGrapheD == '' : xGrapheD = 200 print "Echec -largueur du graphe [graph width]-" if yGrapheD == '' : yGrapheD = 200 print "Echec -hauteur du graphe [graph heigh]-" if echelleD == '' : echelleD = '1' print "Echec -echelle (pix/m) [scale (pixel/m)]-" if anamorphismeD == '' : anamorphismeD = 1 print "Echec -coeficient d anamorphisme vertical" print " -vertical scale over factor" if obliciteD == '' : obliciteD = 10 print "Echec -oblicite initiale" print " -vertical deviation angle at startup" if dessinerTrianglePisteD == '' : dessinerTrianglePisteD = '1' print "Echec -dessiner triangle sens piste" print " -runway direction triangle drawing" if ecrireNomPisteD == '' : ecrireNomPisteD = '1' print "Echec -ecrire nom piste" print " -runway name writing" if dessinerVecteur100mD == '' : dessinerVecteur100mD = '1' print "Echec -dessiner vecteur vertical 100 m" print " -vertical vector drawing (high=100m)" if aerodromeD == '' : aerodromeD = 'Belfort-Chaux' print "Echec -aerodrome initial [startup airfield]-" if nomPisteChoisieD == '' : nomPisteChoisieD = '18G' print "Echec -piste initiale [startup runway]-" if annotationGeneVolPrincipalD == '' : annotationGeneVolPrincipalD = 'Nom Fichier' print "Echec -annotation generale du vol principal" print " -general annotation of main flight" if annotationInterVolPrincipalD == '' : annotationInterVolPrincipalD = 'aucune' print "Echec -annotation intermediaire du vol principal" print " -intermediate indication of main flight" if pasAnnotInterVolPrincipalD == '' : pasAnnotInterVolPrincipalD = '2' print "Echec -pas d annotation intermediaire" print " -intermediate annotation step" # donner une valeur numerique aux variables si besoin try : xGrapheD = int(xGrapheD) except ValueError , libelle : xGrapheD = 600 else : pass try : yGrapheD = int(yGrapheD) except ValueError , libelle : yGrapheD = 400 else : pass try : echelleD = float(echelleD) except ValueError , libelle : echelleD = 1.0 else : pass if int(echelleD) == echelleD : echelleD = int(echelleD) try : anamorphismeD = int(anamorphismeD) except ValueError , libelle : anamorphismeD = 1 else : pass try : obliciteD = float(obliciteD) except ValueError , libelle : obliciteD = 10.0 else : pass try : dessinerTrianglePisteD = int(dessinerTrianglePisteD) except ValueError , libelle : dessinerTrianglePisteD = 1 else : pass try : ecrireNomPisteD = int(ecrireNomPisteD) except ValueError , libelle : ecrireNomPisteD = 1 else : pass try : dessinerVecteur100mD = int(dessinerVecteur100mD) except ValueError , libelle : dessinerVecteur100mD = 1 else : pass try : pasAnnotInterVolPrincipalD = int(pasAnnotInterVolPrincipalD) except ValueError , libelle : pasAnnotInterVolPrincipalD = 2 else : pass # transmettre listePreferences = [ formatPrefD , langageD , \ xGrapheD,yGrapheD,echelleD,anamorphismeD,obliciteD,\ dessinerTrianglePisteD,ecrireNomPisteD,dessinerVecteur100mD,\ aerodromeD,nomPisteChoisieD,\ annotationGeneVolPrincipalD,annotationInterVolPrincipalD,\ pasAnnotInterVolPrincipalD] return listePreferences #####=====#####=====#####=====#####=====#####=====#####=====#####=====##### #####=================================================================##### ##### C L A S S E S ##### #####=================================================================##### #####=====#####=====#####=====#####=====#####=====#####=====#####=====##### ########################################################################### class ConstruireFenetreDeBase : ########################################################################### def __init__ ( self , parent , cheminHome , langage , xGraphe , yGraphe , echelle , anamorphisme , oblicite , dessinerTrianglePiste , ecrireNomPiste , dessinerVecteur100m , aerodrome , nomPisteChoisie , limiterVolPrincipal , limiterVolComparatif , annotationGeneVolPrincipal , annotationInterVolPrincipal , pasAnnotInterVolPrincipal ) : # ==============================# # 0 ) Variables initiales # # ==============================# self.parent = parent self.cheminHome = cheminHome self.langage = langage self.xGraphe = xGraphe self.yGraphe = yGraphe self.echelle = str(echelle) + ' pix/m' self.anamorphisme = anamorphisme self.oblicite = oblicite self.dessinerTrianglePiste = dessinerTrianglePiste self.ecrireNomPiste = ecrireNomPiste self.dessinerVecteur100m = dessinerVecteur100m self.aerodrome = aerodrome self.nomPisteChoisie = nomPisteChoisie self.limiterVolPrincipal = limiterVolPrincipal self.limiterVolComparatif = limiterVolComparatif self.annotationGeneVolPrincipal = annotationGeneVolPrincipal self.annotationInterVolPrincipal = annotationInterVolPrincipal self.pasAnnotInterVolPrincipal = pasAnnotInterVolPrincipal #--- self.uniteAnnotInterVolPrincipal = 1 self.affichageVent = 1 self.affichageVitesseVent = 0 # ====================================================================# # 1 ) Variables particulieres # # ====================================================================# # Variables initialisees # ====================== self.orientation = 0 self.listeToutesInfosTousAerodromes = [] self.listeToutesInfosAerodromeChoisi = [ [],[],[],[],[],[],[],[] ] self.listeInfoToutesPistesPlaneur = [] self.listeInfoPisteChoisie = ['-','herbe','--',0,[]] self.orientation = 0 self.nomPisteChoisie = '-' try : self.echelleFloat = float(self.echelle[:-6]) except ValueError , libelle : self.echelleFloat = 1.0 self.echelle = '1 pix/m' else : pass self.nomFichierVolPrincipal = '' self.fichierBrutVolPrincipal = [] self.pointsVolPrincipal = [] self.pointsLimitesVolPrincipal = [] self.nomsVolsComparatifs = [] self.VolsComparatifs = [] self.VolsComparatifsLimites = [] self.texteAnnotationGeneraleVolPrincipal = "" self.listeAnnotIntermediaireVolPrincipal = [] self.directionMonoVent = 0 self.vitesseMonoVent = 0 self.listeVecteursVent = [] # Variables construites # ===================== # Language if self.langage == 'en' : pass elif self.langage == 'fr' : pass else : self.langage = 'en' if self.langage == 'fr' : self.langageA = 'Francais' elif self.langage == 'en' : self.langageA = 'English' else : self.langageA = 'English' # Mode de Fonctionnement if self.langage == 'en' : self.modeFonctionnement = 'Winch Launch' elif self.langage == 'fr' : self.modeFonctionnement = 'Treuillage' else : self.modeFonctionnement = '' # Mode de Limitation (vol principal) if self.langage == 'en' : self.modeLimitationVolPrincipal = 'Automatic' elif self.langage == 'fr' : self.modeLimitationVolPrincipal = 'Automatique' else : self.modeLimitationVolPrincipal = '' # Mode de Definition du Vent if self.langage == 'en' : self.modeDefinitionDuVent = 'No' elif self.langage == 'fr' : self.modeDefinitionDuVent = 'Nul' else : self.modeDefinitionDuVent = '' # Variables dont les donnees vont etre recuperees # =============================================== # Aerodrome self.listeToutesInfosTousAerodromes = \ faireLaListeToutesInfosTousAerodromes ( self.cheminHome ) # Definition de l aerodrome for a in self.listeToutesInfosTousAerodromes : if a[1] == self.aerodrome : self.listeToutesInfosAerodromeChoisi = a self.listeInfoToutesPistesPlaneur = a[3] break else : self.listeToutesInfosAerodromeChoisi = \ self.listeToutesInfosTousAerodromes[0] self.listeInfoToutesPistesPlaneur = \ self.listeToutesInfosTousAerodromes[0][3] # Definition de la piste for a in self.listeInfoToutesPistesPlaneur : if a[0] == self.nomPisteChoisie : self.listeInfoPisteChoisie = a self.orientation = a[3] else : self.nomPisteChoisie = self.listeInfoToutesPistesPlaneur[0][0] self.listeInfoPisteChoisie = \ self.listeInfoToutesPistesPlaneur[0] self.orientation = self.listeInfoToutesPistesPlaneur[0][3] # ====================================================================# # Creer des variables de transfert entre 'python' et 'Tkinter' # # ====================================================================# self.echelleVar = Tkinter.StringVar() # self.anamorphismeVar = Tkinter.IntVar () # self.aerodromeVar = Tkinter.StringVar() # self.nomPisteChoisieVar = Tkinter.StringVar() # self.orientationVar = Tkinter.IntVar () # self.obliciteVar = Tkinter.IntVar () # self.limiterVolPrincVar = Tkinter.IntVar () # self.limiterVolCompVar = Tkinter.IntVar () # self.annotGeneVolPrincVar = Tkinter.StringVar() # self.annotInterVolPrVar = Tkinter.StringVar() # self.pasAnnotInterVolPrVar = Tkinter.IntVar () # self.unitAnnotInterVolPrVar = Tkinter.IntVar () # self.dessinerTriangPisteVar = Tkinter.IntVar () # self.ecrireNomPisteVar = Tkinter.IntVar () # self.dessinerVecteur100mVar = Tkinter.IntVar () # self.langageAVar = Tkinter.StringVar() # self.modeFonctionnementVar = Tkinter.StringVar() # self.modeLimitVolPrincVar = Tkinter.StringVar() # self.modeDefDuVentVar = Tkinter.StringVar() # self.affichageVentVar = Tkinter.IntVar () # self.affichageVitVentVar = Tkinter.IntVar () # self.directionMonoVentVar = Tkinter.IntVar () # self.vitesseMonoVentVar = Tkinter.IntVar () # self.echelleVar.set (self.echelle ) # self.anamorphismeVar.set (self.anamorphisme ) # self.aerodromeVar.set (self.aerodrome ) # self.nomPisteChoisieVar.set (self.nomPisteChoisie ) # self.orientationVar.set (self.orientation ) # self.obliciteVar.set (self.oblicite ) # self.limiterVolPrincVar.set (self.limiterVolPrincipal ) # self.limiterVolCompVar.set (self.limiterVolComparatif ) # self.annotGeneVolPrincVar.set (self.annotationGeneVolPrincipal ) # self.annotInterVolPrVar.set (self.annotationInterVolPrincipal) # self.pasAnnotInterVolPrVar.set (self.pasAnnotInterVolPrincipal ) # self.dessinerTriangPisteVar.set (self.dessinerTrianglePiste ) # self.ecrireNomPisteVar.set (self.ecrireNomPiste ) # self.dessinerVecteur100mVar.set (self.dessinerVecteur100m ) # self.langageAVar.set (self.langageA ) # self.unitAnnotInterVolPrVar.set (self.uniteAnnotInterVolPrincipal) # self.modeFonctionnementVar.set (self.modeFonctionnement ) # self.modeLimitVolPrincVar.set (self.modeLimitationVolPrincipal ) # self.modeDefDuVentVar.set (self.modeDefinitionDuVent ) # self.affichageVentVar.set (self.affichageVent ) # self.affichageVitVentVar.set (self.affichageVitesseVent ) # self.directionMonoVentVar.set (self.directionMonoVent ) # self.vitesseMonoVentVar.set (self.vitesseMonoVent ) # # ===================================================================== # 2 ) Creer le graphe principal # # ===================================================================== self.dessin = Pmw.ScrolledCanvas( self.parent , borderframe = 5 , usehullsize = 1 , hull_width = self.xGraphe , hull_height = self.yGraphe , canvas_bg = 'steelblue' ) self.dessin.configure ( vscrollmode = 'static' , hscrollmode = 'static') # ========================== # 3 ) Creer La Barre DE MENU # ========================== self.bdm = Pmw.MenuBar( self.parent, hull_relief = 'raised', hull_borderwidth = 1 ) if self.langage == 'fr' : self.creerMenuDeroulantFrancais() elif self.langage == 'en' : self.creerMenuDeroulantEnglish () else : self.creerMenuDeroulantEnglish () # ==================================== # 4 ) Creer Les curseurs # ==================================== self.curseurOrientation = Tkinter.Scale ( self.parent , orient = 'horizontal' , showvalue = 0 , from_ = 0 , to = 360 , tickinterval = 30 , command = self.actionCurseurOrientation , variable = self.orientationVar ) self.curseurOblicite = Tkinter.Scale ( self.parent , orient = 'vertical' , showvalue = 0 , from_ = 0 , to = 90 , tickinterval = 15 , command = self.actionCurseurOblicite , variable = self.obliciteVar ) # ====================== # 5 ) Placer les widgets # ====================== self.bdm.pack ( fill = 'x' ) self.curseurOblicite.pack (side = 'right' , padx = 1, pady = 1 , fill = 'both' , expand=0 ) self.curseurOrientation.pack(side = 'bottom', padx = 1, pady = 1 , fill = 'both' , expand=0 ) self.dessin.pack (side = 'top' , padx = 1, pady = 1 , fill = 'both' , expand=1 ) # ============== # 6 ) 1er Dessin # ============== self.centrePiste = self.calculerCentrePiste () self.longueurPiste = self.calculerLongueurPiste () self.pointeTrianglePiste = self.calculerPointeTrianglePiste () self.centreTrianglePiste = self.calculerCentreTrianglePiste () self.creerBoutonsMenuPistes () self.redessinerTout () # =========================================== # Fonctions propres a cette classe : methodes # =========================================== # =========================================== def creerMenuDeroulantFrancais ( self ) : # =========================================== # ) Menu Fichier # ============ self.bdm.addmenu( 'Fichier' , 'operations sur les fichiers' ) self.bdm.addmenuitem( 'Fichier' , 'command' , command = self.fichierFermer , label = 'Fermer' ) self.bdm.addmenuitem( 'Fichier' , 'command' , command = self.fichierQuitter , label = 'Quitter' ) # ) Menu Edition # ============ self.bdm.addmenu( 'Edition' , 'parametres generaux' ) self.bdm.addcascademenu( 'Edition' , 'Echelle' , 'Echelle en pix / m' ) li = [ '0.01 pix/m' , '0.1 pix/m' , '0.2 pix/m' , \ '0.5 pix/m' , '0.7 pix/m' , \ '1 pix/m' , \ '2 pix/m' , '3 pix/m' , '4 pix/m' , '5 pix/m' , \ '10 pix/m' , '20 pix/m' , '50 pix/m' , '100 pix/m' ] for i in li : self.bdm.addmenuitem( 'Echelle' , 'radiobutton' , variable = self.echelleVar , command = self.calcValBaseRedessTt , label = str(i) ) self.bdm.addcascademenu( 'Edition' , 'Anamorphisme' , 'rapport d echelle = echelle verticale / echelle horizontale' ) for i in [1,2,3,4] : self.bdm.addmenuitem( 'Anamorphisme' , 'radiobutton' , variable = self.anamorphismeVar , command = self.calcValBaseRedessTt , label = str(i) ) self.bdm.addcascademenu( 'Edition' , 'Langage' , 'langue des termes des menus deroulants' ) for i in ['English','Francais'] : self.bdm.addmenuitem( 'Langage' , 'radiobutton' , variable = self.langageAVar , command = self.changerLangage , label = str(i) ) self.bdm.addmenuitem('Edition', 'separator') self.bdm.addcascademenu( 'Edition' , 'Mode' , 'theme de l analyse' ) for i in ['Treuillage'] : self.bdm.addmenuitem( 'Mode' , 'radiobutton' , variable = self.modeFonctionnementVar , command = self.changerMode , label = str(i) ) self.bdm.addmenuitem('Edition', 'separator') self.bdm.addcascademenu( 'Edition' , 'Limitation' , 'selectionner la partie du vol a etudier' ) for i in ['Automatique'] : self.bdm.addmenuitem( 'Limitation' , 'radiobutton' , variable = self.modeLimitVolPrincVar , command = self.changerLimitation , label = str(i) ) self.bdm.addmenuitem('Edition', 'separator') self.bdm.addcascademenu( 'Edition' , 'Vent' , 'ce qui concerne le vent' ) self.bdm.addmenuitem( 'Vent' , 'radiobutton' , variable = self.modeDefDuVentVar , command = self.definirVentNul , label = 'Nul' ) self.bdm.addmenuitem( 'Vent' , 'radiobutton' , variable = self.modeDefDuVentVar , command = self.definirMonoVent , label = 'Definir' ) self.bdm.addmenuitem('Vent', 'separator') self.bdm.addmenuitem( 'Vent' , 'checkbutton' , variable = self.affichageVentVar , command = self._afficherVent , label = 'Afficher' ) self.bdm.addmenuitem( 'Vent' , 'checkbutton' , variable = self.affichageVitVentVar , command = self._afficherVent , label = 'Vitesse' ) # ) Menu Aerodrome # ============== self.bdm.addmenu( 'Aerodrome' , 'ce qui concerne l Aerodrome' ) for i in self.listeToutesInfosTousAerodromes : self.bdm.addmenuitem( 'Aerodrome' , 'radiobutton' , variable = self.aerodromeVar , command = self.choisirAerodrome , label = str(i[1]) ) # ) Menu Piste # ============== self.bdm.addmenu( 'Piste' , 'ce qui concerne la piste' ) self.bdm.addmenuitem( 'Piste' , 'checkbutton' , variable = self.dessinerTriangPisteVar , command = self.calcValBaseRedessTt , label = 'Sens' ) self.bdm.addmenuitem( 'Piste' , 'checkbutton' , variable = self.ecrireNomPisteVar , command = self.calcValBaseRedessTt , label = 'Nom' ) self.bdm.addmenuitem( 'Piste' , 'checkbutton' , variable = self.dessinerVecteur100mVar , command = self.calcValBaseRedessTt , label = 'Vecteur vertical 100 m' ) self.bdm.addmenuitem('Piste', 'separator') # ) Menu Vol # ============= self.bdm.addmenu( 'Vol' , 'selection du vol a afficher' ) self.bdm.addmenuitem( 'Vol' , 'command' , command = self.ouvrirPrincipal , label = 'Ouvrir' ) self.bdm.addmenuitem( 'Vol' , 'checkbutton' , variable = self.limiterVolPrincVar , command = self.limiterPtsVolPrincipal , label = 'Limiter' ) self.bdm.addcascademenu( 'Vol' , 'Denomination' , 'ajoute une indication unique sur la courbe' ) for a in ['aucune','Nom Fichier','Pilote','Planeur','Immatriculation', \ 'Date','Heure','Pilote+Immat+Date+heure'] : self.bdm.addmenuitem( 'Denomination' , 'radiobutton' , variable = self.annotGeneVolPrincVar , command = self.annotterGeneVolPrincipal , label = a ) self.bdm.addcascademenu( 'Vol' , 'Annotation' , 'ajoute une indication sur la courbe' , tearoff = 1 ) for a in ['aucune','Vitesse Galileenne (Km/h)',\ 'Vitesse Relative (Km/h)','Vario (m/s)','Angle (deg)',\ 'Hauteur (m)','Altitude (m)','Chrono (s)', \ 'Puissance massique (W/Kg)','Puissance massique (ch/quintal)',\ 'Energie massique (J/Kg)'] : self.bdm.addmenuitem( 'Annotation' , 'radiobutton' , variable = self.annotInterVolPrVar , command = self.annotterInterVolPrincipal , label = a ) self.bdm.addmenuitem( 'Vol' , 'checkbutton' , variable = self.unitAnnotInterVolPrVar , command = self.annotterInterVolPrincipal , label = 'Unite' ) self.bdm.addcascademenu( 'Vol' , 'Pas' , 'defini le pas de calcul et d affichage de l anotation') for a in [1,2,3,4,5] : self.bdm.addmenuitem( 'Pas' , 'radiobutton' , variable = self.pasAnnotInterVolPrVar , command = self.annotterInterVolPrincipal , label = str(a) ) self.bdm.addmenuitem('Vol', 'separator') self.bdm.addcascademenu( 'Vol' , 'Comparatif' , 'Echelle 1 = 1pix / m' ) self.bdm.addmenuitem( 'Comparatif' , 'command' , command = self.ouvrirComparatif , label = 'Ouvrir' ) self.bdm.addmenuitem( 'Comparatif' , 'checkbutton' , variable = self.limiterVolCompVar , command = self.limiterPtsVolComparatif , label = 'Limiter' ) self.bdm.addmenuitem( 'Comparatif' , 'command' , command = self.effacerComparatifs , label = 'Effacer Tous' ) # ) Menu Aide # ============= self.bdm.addmenu( 'Aide' , 'Informations d assistance' , side='right' ) self.bdm.addmenuitem( 'Aide' , 'command' , command = self._fenetreSignification , label = 'Signification' ) self.bdm.addmenuitem( 'Aide' , 'command' , command = self._fenetreAuteur , label = 'Auteur' ) self.bdm.addmenuitem( 'Aide' , 'command' , command = self._fenetreLicence , label = 'Licence' ) self.bdm.addmenuitem( 'Aide' , 'command' , command = self._fenetreAnalyserVol , label = 'Analyser une treuillee' ) self.bdm.addmenuitem( 'Aide' , 'command' , command = self._fenetreCreerAerodrome , label = 'Creer un aerodrome' ) self.bdm.addmenuitem( 'Aide' , 'command' , command = self._fenetreModifierPreferences , label = 'Modifier les preferences' ) self.bdm.addmenuitem( 'Aide' , 'command' , command = self._fenetrePrecautionsUtilisation , label = """Precautions d'utilisation""" ) # =========================================== def creerMenuDeroulantEnglish ( self ) : # =========================================== # ) Menu Fichier # ============ self.bdm.addmenu( 'File' , 'operations sur les fichiers' ) self.bdm.addmenuitem( 'File' , 'command' , command = self.fichierFermer , label = 'Close' ) self.bdm.addmenuitem( 'File' , 'command' , command = self.fichierQuitter , label = 'Quit' ) # ) Menu Edition # ============ self.bdm.addmenu( 'Edit' , 'parametres generaux' ) self.bdm.addcascademenu( 'Edit' , 'Scale' , 'scale in pix / m' ) li = [ '0.01 pix/m' , '0.1 pix/m' , '0.2 pix/m' , \ '0.5 pix/m' , '0.7 pix/m' , \ '1 pix/m' , \ '2 pix/m' , '3 pix/m' , '4 pix/m' , '5 pix/m' , \ '10 pix/m' , '20 pix/m' , '50 pix/m' , '100 pix/m' ] for i in li : self.bdm.addmenuitem( 'Scale' , 'radiobutton' , variable = self.echelleVar , command = self.calcValBaseRedessTt , label = str(i) ) self.bdm.addcascademenu( 'Edit' , 'Anamorphisme' , 'rapport d echelle = echelle verticale / echelle horizontale' ) for i in [1,2,3,4] : self.bdm.addmenuitem( 'Anamorphisme' , 'radiobutton' , variable = self.anamorphismeVar , command = self.calcValBaseRedessTt , label = str(i) ) self.bdm.addcascademenu( 'Edit' , 'Language' , 'langue des termes des menus deroulants' ) for i in ['English','Francais'] : self.bdm.addmenuitem( 'Language' , 'radiobutton' , variable = self.langageAVar , command = self.changerLangage , label = str(i) ) self.bdm.addmenuitem('Edit', 'separator') self.bdm.addcascademenu( 'Edit' , 'Mode' , 'theme de l analyse' ) for i in ['Winch Launch'] : self.bdm.addmenuitem( 'Mode' , 'radiobutton' , variable = self.modeFonctionnementVar , command = self.changerMode , label = str(i) ) self.bdm.addmenuitem('Edit', 'separator') self.bdm.addcascademenu( 'Edit' , 'Limitation' , 'selectionner la partie du vol a etudier' ) for i in ['Automatic'] : self.bdm.addmenuitem( 'Limitation' , 'radiobutton' , variable = self.modeLimitVolPrincVar , command = self.changerLimitation , label = str(i) ) self.bdm.addmenuitem('Edit', 'separator') self.bdm.addcascademenu( 'Edit' , 'Wind' , 'ce qui concerne le vent' ) self.bdm.addmenuitem( 'Wind' , 'radiobutton' , variable = self.modeDefDuVentVar , command = self.definirVentNul , label = 'No' ) self.bdm.addmenuitem( 'Wind' , 'radiobutton' , variable = self.modeDefDuVentVar , command = self.definirMonoVent , label = 'Define' ) self.bdm.addmenuitem('Wind', 'separator') self.bdm.addmenuitem( 'Wind' , 'checkbutton' , variable = self.affichageVentVar , command = self._afficherVent , label = 'Draw' ) self.bdm.addmenuitem( 'Wind' , 'checkbutton' , variable = self.affichageVitVentVar , command = self._afficherVent , label = 'Speed' ) # ) Menu Aerodrome # ============== self.bdm.addmenu( 'Airfield' , 'ce qui concerne l Aerodrome' ) for i in self.listeToutesInfosTousAerodromes : self.bdm.addmenuitem( 'Airfield' , 'radiobutton' , variable = self.aerodromeVar , command = self.choisirAerodrome , label = str(i[1]) ) # ) Menu Piste # ============== self.bdm.addmenu( 'Runway' , 'ce qui concerne la piste' ) self.bdm.addmenuitem( 'Runway' , 'checkbutton' , variable = self.dessinerTriangPisteVar , command = self.calcValBaseRedessTt , label = 'Direction' ) self.bdm.addmenuitem( 'Runway' , 'checkbutton' , variable = self.ecrireNomPisteVar , command = self.calcValBaseRedessTt , label = 'Name' ) self.bdm.addmenuitem( 'Runway' , 'checkbutton' , variable = self.dessinerVecteur100mVar , command = self.calcValBaseRedessTt , label = 'Vertical Vector 100 m' ) self.bdm.addmenuitem('Runway', 'separator') # ) Menu Vol # ============= self.bdm.addmenu( 'Flight' , 'selection du vol a afficher' ) self.bdm.addmenuitem( 'Flight' , 'command' , command = self.ouvrirPrincipal , label = 'Open' ) self.bdm.addmenuitem( 'Flight' , 'checkbutton' , variable = self.limiterVolPrincVar , command = self.limiterPtsVolPrincipal , label = 'Limit' ) self.bdm.addcascademenu( 'Flight' , 'Designation' , 'ajoute une indication unique sur la courbe' ) for a in ['none','Name of the File','Pilot','Glider','Callsign', \ 'Date','Hour','Pilot+Callsign+Date+hour'] : self.bdm.addmenuitem( 'Designation' , 'radiobutton' , variable = self.annotGeneVolPrincVar , command = self.annotterGeneVolPrincipal , label = a ) self.bdm.addcascademenu( 'Flight' , 'Annotation' , 'ajoute une indication sur la courbe' , tearoff = 1 ) for a in ['none','Galilean Speed (Km/h)','Air Speed (Km/h)', \ 'Vario (m/s)','Angle (deg)','High (m)', \ 'Altitude (m)','Stopwatch (s)', \ 'Power to Mass (W/Kg)','Power to Mass (hp/100Kg)', \ 'Energy to Mass (J/Kg)'] : self.bdm.addmenuitem( 'Annotation' , 'radiobutton' , variable = self.annotInterVolPrVar , command = self.annotterInterVolPrincipal , label = a ) self.bdm.addmenuitem( 'Flight' , 'checkbutton' , variable = self.unitAnnotInterVolPrVar , command = self.annotterInterVolPrincipal , label = 'Unit' ) self.bdm.addcascademenu( 'Flight' , 'Pitch' , 'defini le pas de calcul et d affichage de l anotation') for a in [1,2,3,4,5] : self.bdm.addmenuitem( 'Pitch' , 'radiobutton' , variable = self.pasAnnotInterVolPrVar , command = self.annotterInterVolPrincipal , label = str(a) ) self.bdm.addmenuitem('Flight', 'separator') self.bdm.addcascademenu( 'Flight' , 'Comparative' , 'Echelle 1 = 1pix / m' ) self.bdm.addmenuitem( 'Comparative' , 'command' , command = self.ouvrirComparatif , label = 'Open' ) self.bdm.addmenuitem( 'Comparative' , 'checkbutton' , variable = self.limiterVolCompVar , command = self.limiterPtsVolComparatif , label = 'Limit' ) self.bdm.addmenuitem( 'Comparative' , 'command' , command = self.effacerComparatifs , label = 'Delete All' ) # ) Menu Aide # ============= self.bdm.addmenu( 'Help' , 'Informations d assistance' , side='right' ) self.bdm.addmenuitem( 'Help' , 'command' , command = self._fenetreSignification , label = 'Meaning' ) self.bdm.addmenuitem( 'Help' , 'command' , command = self._fenetreAuteur , label = 'Writer' ) self.bdm.addmenuitem( 'Help' , 'command' , command = self._fenetreLicence , label = 'Licence' ) self.bdm.addmenuitem( 'Help' , 'command' , command = self._fenetreAnalyserVol , label = 'winch lunching analysis' ) self.bdm.addmenuitem( 'Help' , 'command' , command = self._fenetreCreerAerodrome , label = 'Create an airfield' ) self.bdm.addmenuitem( 'Help' , 'command' , command = self._fenetreModifierPreferences , label = 'Modify preferences' ) self.bdm.addmenuitem( 'Help' , 'command' , command = self._fenetrePrecautionsUtilisation , label = 'Usage precautions' ) # =========================================== def changerLangage ( self ) : # =========================================== # effacer les anciens menus if self.langage == 'fr' : self.effacerMenuDeroulantFrancais () elif self.langage == 'en' : self.effacerMenuDeroulantEnglish () # recuperer la langue choisie self.langageA = self.langageAVar.get() # modifier les variables de transfert vers Tkinter if self.langageA == 'Francais' and self.langage == 'en' : self.traduireVariablesENversFR () elif self.langageA == 'English' and self.langage == 'fr' : self.traduireVariablesFRversEN () # mettre a jour la variable linguistique if self.langageA == 'Francais' : self.langage = 'fr' elif self.langageA == 'English' : self.langage = 'en' # recreer les menus de la barre de menus deroulants if self.langageA == 'Francais' : self.creerMenuDeroulantFrancais () elif self.langageA == 'English' : self.creerMenuDeroulantEnglish () # recreer les boutons des pistes self.creerBoutonsMenuPistes () # refaire les calculs et le graphe (si la langue change les unites ...) self.calculerValeursDeBase () self.redessinerTout () # =========================================== def effacerMenuDeroulantFrancais ( self ) : # =========================================== self.bdm.deletemenu ( 'Fichier' ) self.bdm.deletemenu ( 'Echelle' ) # self.bdm.deletemenu ( 'Anamorphisme' ) # self.bdm.deletemenu ( 'Langage' ) # self.bdm.deletemenu ( 'Mode' ) # self.bdm.deletemenu ( 'Limitation' ) # self.bdm.deletemenu ( 'Vent' ) # self.bdm.deletemenu ( 'Edition' )####### self.bdm.deletemenu ( 'Aerodrome' ) self.bdm.deletemenu ( 'Piste' ) self.bdm.deletemenu ( 'Denomination' ) # self.bdm.deletemenu ( 'Annotation' ) # self.bdm.deletemenu ( 'Pas' ) # self.bdm.deletemenu ( 'Comparatif' ) # self.bdm.deletemenu ( 'Vol' )############ self.bdm.deletemenu ( 'Aide' ) # =========================================== def effacerMenuDeroulantEnglish ( self ) : # =========================================== self.bdm.deletemenu ( 'File' ) self.bdm.deletemenu ( 'Scale' ) # self.bdm.deletemenu ( 'Anamorphisme' ) # self.bdm.deletemenu ( 'Language' ) # self.bdm.deletemenu ( 'Mode' ) # self.bdm.deletemenu ( 'Limitation' ) # self.bdm.deletemenu ( 'Wind' ) # self.bdm.deletemenu ( 'Edit' )########## self.bdm.deletemenu ( 'Airfield' ) self.bdm.deletemenu ( 'Runway' ) self.bdm.deletemenu ( 'Designation' ) # self.bdm.deletemenu ( 'Annotation' ) # self.bdm.deletemenu ( 'Pitch' ) # self.bdm.deletemenu ( 'Comparative' ) # self.bdm.deletemenu ( 'Flight' )######### self.bdm.deletemenu ( 'Help' ) # =========================================== def traduireVariablesFRversEN ( self ) : # =========================================== if self.modeFonctionnementVar.get() == 'Treuillage' : self.modeFonctionnementVar.set('Winch Launch') elif self.modeFonctionnementVar.get() == 'Elastique' : self.modeFonctionnementVar.set('Elastic') elif self.modeFonctionnementVar.get() == 'Depart dans la Pente' : self.modeFonctionnementVar.set('Start in the Slope') if self.modeLimitVolPrincVar.get() == 'Automatique' : self.modeLimitVolPrincVar.set('Automatic') elif self.modeLimitVolPrincVar.get() == 'Manuelle' : self.modeLimitVolPrincVar.set('Manual') if self.modeDefDuVentVar.get() == 'Nul' : self.modeDefDuVentVar.set('No') elif self.modeDefDuVentVar.get() == 'Definir' : self.modeDefDuVentVar.set('Define') elif self.modeDefDuVentVar.get() == 'Definir-multi' : self.modeDefDuVentVar.set('Define-multi') elif self.modeDefDuVentVar.get() == 'Deviner-mono' : self.modeDefDuVentVar.set('Guess-mono') elif self.modeDefDuVentVar.get() == 'Deviner-multi' : self.modeDefDuVentVar.set('Guess-multi') if self.annotGeneVolPrincVar.get() == 'aucune' : self.annotGeneVolPrincVar.set('none') elif self.annotGeneVolPrincVar.get() == 'Nom Fichier' : self.annotGeneVolPrincVar.set('Name of the File') elif self.annotGeneVolPrincVar.get() == 'Pilote' : self.annotGeneVolPrincVar.set('Pilot') elif self.annotGeneVolPrincVar.get() == 'Planeur' : self.annotGeneVolPrincVar.set('Glider') elif self.annotGeneVolPrincVar.get() == 'Immatriculation' : self.annotGeneVolPrincVar.set('Callsign') elif self.annotGeneVolPrincVar.get() == 'Date' : self.annotGeneVolPrincVar.set('Date') elif self.annotGeneVolPrincVar.get() == 'Heure' : self.annotGeneVolPrincVar.set('Hour') elif self.annotGeneVolPrincVar.get() == 'Pilote+Immat+Date+heure' : self.annotGeneVolPrincVar.set('Pilot+Callsign+Date+hour') if self.annotInterVolPrVar.get() == 'aucune' : self.annotInterVolPrVar.set('none') elif self.annotInterVolPrVar.get() == 'Vitesse Galileenne (Km/h)' : self.annotInterVolPrVar.set('Galilean Speed (Km/h)') elif self.annotInterVolPrVar.get() == 'Vitesse Relative (Km/h)' : self.annotInterVolPrVar.set('Air Speed (Km/h)') elif self.annotInterVolPrVar.get() == 'Vario (m/s)' : self.annotInterVolPrVar.set('Vario (m/s)') elif self.annotInterVolPrVar.get() == 'Angle (deg)' : self.annotInterVolPrVar.set('Angle (deg)') elif self.annotInterVolPrVar.get() == 'Hauteur (m)' : self.annotInterVolPrVar.set('High (m)') elif self.annotInterVolPrVar.get() == 'Altitude (m)' : self.annotInterVolPrVar.set('Altitude (m)') elif self.annotInterVolPrVar.get() == 'Chrono (s)' : self.annotInterVolPrVar.set('Stopwatch (s)') elif self.annotInterVolPrVar.get() == 'Puissance massique (W/Kg)' : self.annotInterVolPrVar.set('Power to Mass (W/Kg)') elif self.annotInterVolPrVar.get() =='Puissance massique (ch/quintal)': self.annotInterVolPrVar.set('Power to Mass (hp/100Kg)') elif self.annotInterVolPrVar.get() == 'Energie massique (J/Kg)' : self.annotInterVolPrVar.set('Energy to Mass (J/Kg)') # =========================================== def traduireVariablesENversFR ( self ) : # =========================================== if self.modeFonctionnementVar.get() == 'Winch Launch' : self.modeFonctionnementVar.set('Treuillage') elif self.modeFonctionnementVar.get() == 'Elastic' : self.modeFonctionnementVar.set('Elastique') elif self.modeFonctionnementVar.get() == 'Start in the Slope' : self.modeFonctionnementVar.set('Depart dans la Pente') if self.modeLimitVolPrincVar.get() == 'Automatic' : self.modeLimitVolPrincVar.set('Automatique') elif self.modeLimitVolPrincVar.get() == 'Manual' : self.modeLimitVolPrincVar.set('Manuelle') if self.modeDefDuVentVar.get() == 'No' : self.modeDefDuVentVar.set('Nul') elif self.modeDefDuVentVar.get() == 'Define' : self.modeDefDuVentVar.set('Definir') elif self.modeDefDuVentVar.get() == 'Define-multi' : self.modeDefDuVentVar.set('Definir-multi') elif self.modeDefDuVentVar.get() == 'Guess-mono' : self.modeDefDuVentVar.set('Deviner-mono') elif self.modeDefDuVentVar.get() == 'Guess-multi' : self.modeDefDuVentVar.set('Deviner-multi') if self.annotGeneVolPrincVar.get() == 'none' : self.annotGeneVolPrincVar.set('aucun') elif self.annotGeneVolPrincVar.get() == 'Name of the File' : self.annotGeneVolPrincVar.set('Nom Fichier') elif self.annotGeneVolPrincVar.get() == 'Pilot' : self.annotGeneVolPrincVar.set('Pilote') elif self.annotGeneVolPrincVar.get() == 'Glider' : self.annotGeneVolPrincVar.set('Planeur') elif self.annotGeneVolPrincVar.get() == 'Callsign' : self.annotGeneVolPrincVar.set('Immatriculation') elif self.annotGeneVolPrincVar.get() == 'Date' : self.annotGeneVolPrincVar.set('Date') elif self.annotGeneVolPrincVar.get() == 'Hour' : self.annotGeneVolPrincVar.set('Heure') elif self.annotGeneVolPrincVar.get() == 'Pilot+Callsign+Date+hour' : self.annotGeneVolPrincVar.set('Pilote+Immat+Date+heure') if self.annotInterVolPrVar.get() == 'none' : self.annotInterVolPrVar.set('aucune') elif self.annotInterVolPrVar.get() == 'Galilean Speed (Km/h)' : self.annotInterVolPrVar.set('Vitesse Galileenne (Km/h)') elif self.annotInterVolPrVar.get() == 'Air Speed (Km/h)' : self.annotInterVolPrVar.set('Vitesse Relative (Km/h)') elif self.annotInterVolPrVar.get() == 'Vario (m/s)' : self.annotInterVolPrVar.set('Vario (m/s)') elif self.annotInterVolPrVar.get() == 'Angle (deg)' : self.annotInterVolPrVar.set('Angle (deg)') elif self.annotInterVolPrVar.get() == 'High (m)' : self.annotInterVolPrVar.set('Hauteur (m)') elif self.annotInterVolPrVar.get() == 'Altitude (m)' : self.annotInterVolPrVar.set('Altitude (m)') elif self.annotInterVolPrVar.get() == 'Stopwatch (s)' : self.annotInterVolPrVar.set('Chrono (s)') elif self.annotInterVolPrVar.get() == 'Power to Mass (W/Kg)' : self.annotInterVolPrVar.set('Puissance massique (W/Kg)') elif self.annotInterVolPrVar.get() == 'Power to Mass (hp/100Kg)': self.annotInterVolPrVar.set('Puissance massique (ch/quintal)') elif self.annotInterVolPrVar.get() == 'Energy to Mass (J/Kg)' : self.annotInterVolPrVar.set('Energie massique (J/Kg)') # =========================================== def changerMode ( self ) : # =========================================== self.modeFonctionnement = self.modeFonctionnementVar.get() if self.modeFonctionnement == 'Treuillage' or \ self.modeFonctionnement == 'Winch Launch' : self.calcValBaseRedessTt else : self.calcValBaseRedessTt # =========================================== def changerLimitation ( self ) : # =========================================== pass # =========================================== def _afficherVent ( self ) : # =========================================== self.calculerValeursDeBase () self.redessinerTout () # =========================================== def definirVentNul ( self ) : # =========================================== self.vitesseMonoVent = 0 self.directionMonoVent = 0 self.listeVecteursVent = [] self.vitesseMonoVentVar.set (self.vitesseMonoVent ) self.directionMonoVentVar.set (self.directionMonoVent ) self.calculerValeursDeBase () self.redessinerTout () # =========================================== def definirMonoVent ( self ) : # =========================================== # recuperer les parametres actuels self.vitesseMonoVent = self.vitesseMonoVentVar.get () self.directionMonoVent = self.directionMonoVentVar.get () # constituer le titre de la fenetre if self.langage == 'fr' : titreFenetre = 'Definir le vent' nomPourDirection = 'Direction (degre)' nomPourVitesse = 'Force (Km/h)' nomPourOK = 'Entrer' nomPourAnnuler = 'Annuler' nomPourVisualiser = 'Visualiser' elif self.langage == 'en' : titreFenetre = 'Wind Definition' nomPourDirection = 'Direction (degre)' nomPourVitesse = 'Speed (Km/h)' nomPourOK = 'Enter' nomPourAnnuler = 'Cancel' nomPourVisualiser = 'See' else : titreFenetre = 'Wind Definition' nomPourDirection = 'Direction (degre)' nomPourVitesse = 'Speed (Km/h)' nomPourOK = 'Enter' nomPourAnnuler = 'Cancel' nomPourVisualiser = 'See' # ouvrir la fenetre de definition du vent fmv = DefinirMonoVent( self , titreFenetre , self.directionMonoVent , self.vitesseMonoVent , nomPourDirection , nomPourVitesse , nomPourOK , nomPourAnnuler , nomPourVisualiser ) # =========================================== def choisirAerodrome ( self ) : # =========================================== # preparation aerodromeA = self.aerodrome self.aerodrome = self.aerodromeVar.get () self.effacerBoutonsMenuPistes () # effacement de reglages if self.aerodrome != aerodromeA : self.vitesseMonoVent = 0 self.directionMonoVent = 0 self.listeVecteursVent = [] self.vitesseMonoVentVar.set (self.vitesseMonoVent ) self.directionMonoVentVar.set (self.directionMonoVent ) # Reconstruire le systeme de donnes de l aerodrome for a in self.listeToutesInfosTousAerodromes : if a[1] == self.aerodrome : self.listeToutesInfosAerodromeChoisi = a self.listeInfoToutesPistesPlaneur = a[3] break # Choisir la piste preferentielle self.listeInfoPisteChoisie = self.listeInfoToutesPistesPlaneur[0] self.nomPisteChoisie = self.listeInfoPisteChoisie [0] self.orientation = self.listeInfoPisteChoisie [3] # Reconstruire les boutons de piste self.nomPisteChoisieVar.set (self.nomPisteChoisie) self.creerBoutonsMenuPistes () # Refaire les calculs et le dessin self.calculerValeursDeBase () self.redessinerTout () # =========================================== def choisirPiste ( self ) : # =========================================== # preparation self.nomPisteChoisie = self.nomPisteChoisieVar.get () # reconstruire le systeme de donnees de la piste for a in self.listeInfoToutesPistesPlaneur : if a[0] == self.nomPisteChoisie : self.listeInfoPisteChoisie = a self.orientation = a[3] # Refaire les calculs et le dessin self.calculerValeursDeBase () self.redessinerTout () # =========================================== def ouvrirPrincipal ( self ) : # =========================================== d = self.cheminHome + '/apoglide/enregistrements GPS' try : self.nomFichierVolPrincipal = \ askopenfilename ( parent = self.parent , initialdir = d , filetypes = [ ("allfiles","*") , ("IGCfiles","*.IGC") , ("IGCfiles","*.igc") ] ) except NameError , libelle : # module tkFileDialog manquant self.fenetreOuvrirVolPrincipal = \ FichierOuvrir ( self , 'principal' , self.cheminHome , 'apoglide/enregistrements GPS' , 'Choisir le vol a etudier' ) else : # essai de lecture (indispensable en cas d'annulation) try : f = open ( self.nomFichierVolPrincipal , 'r' ) except TypeError , libelle : pass except IOError , libelle : pass else : # lecture self.fichierBrutVolPrincipal = f.readlines() f.close() # extrire les lignes utiles listeLignesCoordonees = extco(self.fichierBrutVolPrincipal) # effacer le fichier vol principal self.pointsVolPrincipal = [] # reconsituer le fichier vol principal for ligne in listeLignesCoordonees : ligneEnForme = decortili (ligne) self.pointsVolPrincipal.append(ligneEnForme) # Re calculer et changer la vue self.calculerValeursDeBase () self.redessinerTout () # =========================================== def limiterPtsVolPrincipal ( self ) : # =========================================== self.calculerValeursDeBase () self.redessinerTout () # =========================================== def annotterGeneVolPrincipal ( self ) : # =========================================== self.calculerValeursDeBase () self.redessinerTout () # =========================================== def annotterInterVolPrincipal ( self ) : # =========================================== self.calculerValeursDeBase () self.redessinerTout () # =========================================== def ouvrirComparatif ( self ) : # =========================================== d = self.cheminHome + '/apoglide/enregistrements GPS' try : nf = askopenfilename ( parent = self.parent , initialdir = d , filetypes = [ ("allfiles","*") , ("IGCfiles","*.IGC") , ("IGCfiles","*.igc") ] ) except NameError , libelle : # module tkFileDialog manquant self.fenetreOuvrirVolComparatif = \ FichierOuvrir ( self , 'comparatif' , self.cheminHome , 'apoglide/enregistrements GPS' , 'Choisir le vol comparatif a ajouter' ) else : # essai de lecture (indispensable en cas d'annulation) try : f = open ( nf , 'r' ) except TypeError , libelle : pass except IOError , libelle : pass else : # lecture volBrut = f.readlines() f.close() # extrire les lignes utiles listeLignesCoordonees = extco ( volBrut ) # initialiser le vol comparatif additionnel volLimiteAuxPts = [] # consituer le vol comparatif additionnel for ligne in listeLignesCoordonees : ligneEnForme = decortili ( ligne ) volLimiteAuxPts.append ( ligneEnForme ) # transmettre le nom du fichier self.nomsVolsComparatifs.append ( nf ) # transmettre en l ajoutant le vol comparatif additionnel self.VolsComparatifs.append( volLimiteAuxPts ) # Re calculer et changer la vue self.calculerValeursDeBase () self.redessinerTout () # =========================================== def limiterPtsVolComparatif ( self ) : # =========================================== self.calculerValeursDeBase () self.redessinerTout () # =========================================== def effacerComparatifs(self) : # =========================================== self.VolsComparatifs = [] self.calculerValeursDeBase () self.redessinerTout () # =========================================== def fichierFermer(self) : # =========================================== self.pointsVolPrincipal = [] self.VolsComparatifs = [] self.calculerValeursDeBase () self.redessinerTout () # =========================================== def fichierQuitter(self) : # =========================================== self.parent.destroy() # =========================================== def _fenetreSignification(self) : # =========================================== if self.langage == 'fr' : titre = 'Signification' elif self.langage == 'en' : titre = 'Meaning' if self.langage == 'fr' : texte = """\n\ apo -> apoapside -> (point le plus elogne sur une orbite)\n\ glide -> glider -> planeur\n\ """ elif self.langage == 'en' : texte = """\n\ apo -> apsis (point of the greatest distance on an elliptical orbit)\n\ glide -> glider\n\ """ fSignif = FenetreTexte( self.parent , titre , texte , 200 , 500 ) # =========================================== def _fenetreAuteur(self) : # =========================================== if self.langage == 'fr' : titre = 'Auteur' elif self.langage == 'en' : titre = 'Writer' if self.langage == 'fr' : texte = 'Ce programme a ete ecrit par :\n\ Marc Archambault instructeur planeur' elif self.langage == 'en' : texte = 'This software was writen by :\n\ Marc Archambault french glider teatcher' fAuteur = FenetreTexte( self.parent , titre , texte , 100 , 500 ) # =========================================== def _fenetreLicence(self) : # =========================================== texte = """This program is free software; you can redistribute it and/or\n\ modify it under the terms of the GNU General Public License\n\ as published by the Free Software Foundation; either version 2\n\ of the License, or (at your option) any later version.\n\ \n\ This program is distributed in the hope that it will be useful,\n\ but WITHOUT ANY WARRANTY; without even the implied warranty of\n\ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n\ GNU General Public License for more details.\n\ \n\ You should have received a copy of the GNU General Public License\n\ along with this program; if not, write to the Free Software\n\ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.""" flicence = FenetreTexte( self.parent , 'Licence GNU GPL' , texte , 200 , 500 ) # =========================================== def _fenetreAnalyserVol(self) : # =========================================== if self.langage == 'fr' : titre = 'Analyser une treuillee' elif self.langage == 'en' : titre = 'winch lunching analysis' if self.langage == 'fr' : texte = """Pour analyser une treuillee :\n\ - placer l'enregistrement GPS dans le repertoire :\n\ ~/apoglide/enregistrements GPS/\n\ - selectionner le vol : Vol / Ouvrir + Selection dans la liste\n\ - faire pivoter la vue avec les curseurs horizontaux et verticaux\n\ - definir des annotation par Vol / Annotations\n\ (pour conserver le menu annotations cliquer sur le pointille)\n\ - comparer la treuillee a d'autres : Vol / Comparatif / Ouvrir...""" elif self.langage == 'en' : texte = """To analyse the winch lunching of a glider :\n\ - put the GPS record file in this directory :\n\ ~/apoglide/enregistrements GPS/\n\ - select a flight : Flight / Open + Select in the list\n\ - rotate the view with horizontal et vertical scroll\n\ - define annotation : Flight / Annotations\n\ (to keep the annotation menu pick on the dot line)\n\ - compare the winch lunching to others : Flight / Comparative / Open...""" fanalyvol = FenetreTexte( self.parent , titre , texte , 200 , 500 ) # =========================================== def _fenetreCreerAerodrome(self) : # =========================================== if self.langage == 'fr' : titre = 'Creer un Aerodrome' elif self.langage == 'en' : titre = 'Create an airfield' if self.langage == 'fr' : texte = """Pour creer un aerodrome :\n\ ------------------------\n\ - allez dans le repertoire ~/apoglide/aerodromes/\n\ - faites un fichier en vous inspirant de ceux\n\ crees automatiquement par le logiciel\n\ - vous pouvez creer un dossier ~/apoglide/airfields/ ou\n\ ~/apoglide/flugplatz/ pour y placer les fichiers aerodromes\n\ Ensuite vous pouvez soit : \n\ - effacer le dossier ~/apoglide/aerodromes/ \n\ - conserver 2 ou 3 dossiers parmi ceux ci-dessus \n\ \n\ Au debut on peut se limiter aux lignes :\n\ ----------------------------------------\n\ - nom\n\ - 1 ligne de definition de la piste principale\n\ \n\ Pour ce qui est des coordonnees geographiques :\n\ -----------------------------------------------\n\ - le mieux est de les mesurer soi meme\n\ ( au GPS par exemple )\n\ - il est aussi possible d'utiliser un logiciel\n\ d'affichage de vues terrestres mais la precision est moindre\n\ \n\ Attention a l'ordre des points des pistes\n\ -----------------------------------------\n\ - les points doivent etre ordonnes dans un des 2\n\ sens de contournement de la piste\n\ - le premier et le dernier points doivent etre\n\ au seuil de piste\n\ \n\ Attention a l'ordre des points du contour\n\ -----------------------------------------\n\ - les points doivent etre ordonnes dans un des 2\n\ sens de contournement de l'aerodrome""" elif self.langage == 'en' : texte = """to create an airfield :\n\ ------------------------\n\ - open the directory ~/apoglide/aerodromes/\n\ - create a file using those created automaticaly\n\ by apoglide\n\ - you can create a repertory ~/apoglide/airfields/ or\n\ ~/apoglide/flugplatz/ to put airfields files\n\ then you can : \n\ - distroy the repertory ~/apoglide/aerodromes/ or\n\ - keep 2 or 3 of these repertories\n\ \n\ At first only a few lines are needed :\n\ --------------------------------------\n\ - nom (name of the airfield)\n\ - piste (1 line to define the main runway)\n\ \n\ For the coordinates :\n\ ---------------------\n\ - the best is to use self made mesures\n\ ( GPS mesure for example )\n\ - you could use an earth view software\n\ by it gives bad accuracy\n\ \n\ Caution to the order of the runway points\n\ -----------------------------------------\n\ - they must be orderd on the way arround the runway\n\ - the first and the last must be at the thressold\n\ \n\ Caution to the order of the boundary points (contour)\n\ -----------------------------------------------------\n\ - they must be orderd on the way arround the airfield""" faero = FenetreTexte( self.parent , titre , texte , 500 , 500 ) # =========================================== def _fenetreModifierPreferences(self) : # =========================================== if self.langage == 'fr' : titre = 'Modifier les Preferences' elif self.langage == 'en' : titre = 'Modify Preferences' if self.langage == 'fr' : texte = """Modifier les preferences :\n\ ------------------------\n\ - aller dans le repertoire ~/apoglide/preferences/\n\ - editer le fichier 'preferences.txt' \n\ - apporter les modifications \n\ - enregistrer\n\ \n\ les modifications seront lues au demarrage suivant\n\ et prendront effet a ce moment la""" elif self.langage == 'en' : texte = """to modify the preferences :\n\ ------------------------\n\ - open the directory ~/apoglide/preferences/\n\ - edit the file 'preferences.txt' \n\ - make appropriate changes \n\ - save\n\ \n\ modifications will be read at next apoglide start\n\ and will be efficient at this moment""" fpref = FenetreTexte( self.parent , titre , texte , 200 , 500 ) # =========================================== def _fenetrePrecautionsUtilisation(self) : # =========================================== if self.langage == 'fr' : titre = """Precautions d'utilisation""" elif self.langage == 'en' : titre = """Usage precautions""" if self.langage == 'fr' : texte = """Precautions d'utilisation :\n\ ------------------------\n\ - Le programme apoglide est fourni sans aucune garantie \n\ Il est en phase d'essai \n\ - Les enregistrements de vol analyses ont quelques defauts :\n\ - Les positions ne sont pas aussi precises qu'on le pense \n\ - Le parametre temps n'est donne qu'a 1 seconde pres \n\ ( pour un enregistrement de position toute les secondes ) \n\ - La qualite de l'analyse est fonction des competences \n\ de celui qui l'effectue \n\ - Le manque de precision du parametre temps se repercute tres \n\ fortement sur les indicateurs donnes en annotation\n\ \n\ L'UTILISATEUR SE SERT DU LOGICIEL SOUS SA PROPRE RESPONSABILITE""" elif self.langage == 'en' : texte = """Usage precautions :\n\ ------------------------\n\ - The software apoglide is given with absolutely no warranty \n\ It is in test phase \n\ - The GPS position files that are used have some defects : \n\ - Positions are not as accurate as it's though \n\ - Time parameter of GPS data is not accurate enough\n\ and it gives huge variations on some parameters\n\ displayed as annotation \n\ - The analysis quality is in relation with the skills \n\ of people who do it \n\ \n\ THE USER USE THE SOFTWARE ON HIS OWN RESPONSIBILITY""" fgaran = FenetreTexte( self.parent , titre , texte , 200 , 500 ) # =========================================== def actionCurseurOrientation ( self , c ) : # =========================================== self.orientationVar.set ( c ) self.redessinerTout () # =========================================== def actionCurseurOblicite ( self , c ) : # =========================================== self.obliciteVar.set ( c ) self.redessinerTout () # =========================================== def calculerValeursDeBase ( self ) : # =========================================== # Acquisition des parametres de base self.limiterVolPrincipal = self.limiterVolPrincVar.get () self.modeLimitationVolPrincipal = self.modeLimitVolPrincVar.get () # self.limiterVolComparatif = self.limiterVolCompVar.get () self.echelle = self.echelleVar.get () self.echelleFloat = float(self.echelle[0:-6]) self.anamorphisme = self.anamorphismeVar.get () self.annotationGeneVolPrincipal = self.annotGeneVolPrincVar.get () self.annotationInterVolPrincipal = self.annotInterVolPrVar.get () self.pasAnnotInterVolPrincipal = self.pasAnnotInterVolPrVar.get () self.uniteAnnotInterVolPrincipal = self.unitAnnotInterVolPrVar.get() self.dessinerTrianglePiste = self.dessinerTriangPisteVar.get() self.ecrireNomPiste = self.ecrireNomPisteVar.get () self.dessinerVecteur100m = self.dessinerVecteur100mVar.get() self.modeDefinitionDuVent = self.modeDefDuVentVar.get () self.vitesseMonoVent = self.vitesseMonoVentVar.get () self.directionMonoVent = self.directionMonoVentVar.get () self.affichageVent = self.affichageVentVar.get () self.affichageVitesseVent = self.affichageVitVentVar.get () # calculs self.centrePiste = self.calculerCentrePiste () self.longueurPiste = self.calculerLongueurPiste () self.pointeTrianglePiste = self.calculerPointeTrianglePiste () self.centreTrianglePiste = self.calculerCentreTrianglePiste () if self.limiterVolPrincipal == 1 : hauteur = self.longueurPiste self.pointsLimitesVolPrincipal = \ limiterVol ( self.pointsVolPrincipal , self.centrePiste , self.longueurPiste , hauteur ) else : self.pointsLimitesVolPrincipal = self.pointsVolPrincipal if self.limiterVolComparatif == 1 : self.VolsComparatifsLimites = [] hauteur = self.longueurPiste for vol in self.VolsComparatifs : volLimite = limiterVol ( vol , self.centrePiste , self.longueurPiste , hauteur ) self.VolsComparatifsLimites.append ( volLimite ) else : self.VolsComparatifsLimites = self.VolsComparatifs self.constituerAnnotationGeneraleVolPrincipal () self.constituerAnnotationIntermediaireVolPrincipal () # calculs concernant le vent self.pointHautDuVol = self.calculerPointHautDuVol () self.listeVecteursVent = self.genererListeVecteursVent () # =========================================== def creerBoutonsMenuPistes (self) : # =========================================== if self.langage == 'fr' : titreMenu = 'Piste' elif self.langage == 'en' : titreMenu = 'Runway' for p in self.listeInfoToutesPistesPlaneur : self.bdm.addmenuitem( titreMenu , 'radiobutton' , variable = self.nomPisteChoisieVar , command = self.choisirPiste , label = str(p[0]) ) # =========================================== def effacerBoutonsMenuPistes (self) : # =========================================== if self.langage == 'fr' : titreMenu = 'Piste' if self.langage == 'en' : titreMenu = 'Runway' self.bdm.deletemenuitems ( titreMenu , 4 , 4+len(self.listeInfoToutesPistesPlaneur) ) # =========================================== def redessinerTout ( self ) : # =========================================== self.orientation = -self.orientationVar.get () # cap selectionne vers la droite de l'ecran self.oblicite = self.obliciteVar.get () self.dessin.delete ('all') self.dessinerContour () self.dessinerTaxiwayAvion () self.dessinerTaxiwayPlaneur () self.dessinerPisteModelisme () self.dessinerPisteAnciennePlaneur () self.dessinerPisteAvion () self.dessinerAutresPistePlaneur () self.dessinerPiste () self.dessinerVecteursVent () self.dessinerVolPrincipal () self.dessinerVolsComparatifs () self.ecrireAnnotationGeneraleVolPrincipal () self.ecrireAnnotationIntermediaireVolPrincipal () self.dessin.resizescrollregion () # =========================================== def calcValBaseRedessTt ( self ) : # =========================================== self.calculerValeursDeBase () self.redessinerTout () # =========================================== def calculerCentrePiste (self) : # =========================================== pts = self.listeInfoPisteChoisie [ 4 ] # points angulaires de la piste x,y,z,n = 0,0,0,0 for p in pts : x , y , z , n = x+p[0] , y+p[1] , z+p[2] , n+1 if n != 0 : x , y , z = x/n , y/n , z/n return [ x , y , z ] # =========================================== def calculerLongueurPiste (self) : # =========================================== pts = self.listeInfoPisteChoisie [ 4 ] # points angulaires de la piste x,y,z,n,d = pts[0][0],pts[0][1],pts[0][2],0,0 for p in pts : d1 = ( (self.centrePiste[0]-p[0])**2+ \ (math.cos(self.centrePiste[0]*math.pi/180)* \ (self.centrePiste[1]-p[1]))**2 )**0.5 d = max ( d , d1 ) d = d * 1852 * 60 * 2 return d # =========================================== def calculerPointeTrianglePiste (self ) : # =========================================== hectoM = 0.01 * self.longueurPiste / 2 x = ( ((hectoM-1)/2)*self.listeInfoPisteChoisie[4][ 0][0] + \ ((hectoM-1)/2)*self.listeInfoPisteChoisie[4][-1][0] + \ self.centrePiste[0] ) / (1+hectoM-1) y = ( ((hectoM-1)/2)*self.listeInfoPisteChoisie[4][ 0][1] + \ ((hectoM-1)/2)*self.listeInfoPisteChoisie[4][-1][1] + \ self.centrePiste[1] ) / (1+hectoM-1) z = ( ((hectoM-1)/2)*self.listeInfoPisteChoisie[4][ 0][2] + \ ((hectoM-1)/2)*self.listeInfoPisteChoisie[4][-1][2] + \ self.centrePiste[2] ) / (1+hectoM-1) return [ x , y , z ] # =========================================== def calculerCentreTrianglePiste (self ) : # =========================================== x = ( self.listeInfoPisteChoisie[4][ 0][0] + \ self.listeInfoPisteChoisie[4][-1][0] + \ self.pointeTrianglePiste[0] ) / 3 y = ( self.listeInfoPisteChoisie[4][ 0][1] + \ self.listeInfoPisteChoisie[4][-1][1] + \ self.pointeTrianglePiste[1] ) / 3 z = ( self.listeInfoPisteChoisie[4][ 0][2] + \ self.listeInfoPisteChoisie[4][-1][2] + \ self.pointeTrianglePiste[2] ) / 3 return [ x , y , z ] # =========================================== def calculerPointHautDuVol (self ) : # =========================================== # initialisation aMax = 0 pMax = [ self.centrePiste[0] , \ self.centrePiste[1] , \ self.centrePiste[2]+100 ] # recherche for p in self.pointsLimitesVolPrincipal : if p[2] > aMax : pMax = p aMax = p[2] # repondre return pMax # =========================================== def genererListeVecteursVent (self ) : # =========================================== # initialisation generale listeVecteursVent = [] # determination du point d'affichage ma = self.centrePiste # ma = manche a air # determination de l'echelle de representation du vent echelleVent = 10.0/111111 #/2 # Construction de la liste de vecteurs # Cas du vent nul if self.modeDefinitionDuVent == 'Nul'or \ self.modeDefinitionDuVent == 'No' : listeVecteursVent = [] # Cas du vent "Mono-Vent" elif self.modeDefinitionDuVent == 'Definir'or \ self.modeDefinitionDuVent == 'Define' : # initialisation particuliere vecteurVent = [] dMV = self.directionMonoVent # Determiner point de base ptBaseVent = [ma[0],ma[1],ma[2]+10] # Calculer la longueur du vecteur longueurVV = echelleVent * self.vitesseMonoVent # Determiner l'extremite du vecteur extremiteVecteurVent = [ \ ma[0] - longueurVV*math.cos(dMV*math.pi/180) , \ ma[1] + longueurVV*math.sin(dMV*math.pi/180) \ / math.cos(ma[0]*math.pi/180) , \ ma[2] ] # Deduire le vecteur vitesse vecteurVent = [ ma , extremiteVecteurVent ] # Creer la liste des vecteurs vitesse listeVecteursVent = [ vecteurVent ] # cas non compris else : listeVecteursVent = [] # repondre return listeVecteursVent # =========================================== def dessinerPiste (self) : # =========================================== pts = self.listeInfoPisteChoisie [4] # points angulaires de la piste pts2 = [] # points projetes # calculer for p in pts : p2 = projPtMA ( p , self.centrePiste , \ self.orientation , self.oblicite , \ self.echelleFloat , self.anamorphisme ) pts2.append ( p2 ) # dessiner le revetement de la piste couleurRevetement = '#a08c69' #'green' '78882e'trop semblable '#6a761B' ptsPolygonePiste =[] for p in pts2 : ptsPolygonePiste.append( p[0]) ptsPolygonePiste.append(-p[2]) self.dessin.create_polygon( ptsPolygonePiste , fill = couleurRevetement ) # dessiner le contour de la piste i = 0 p0 ,pMoins = pts2[0] , pts2[0] for p in pts2 : if i > 0 : self.dessin.create_line( pMoins[0] , -pMoins[2] , p[0] , -p[2] , fill='black' ) pMoins = p i = i + 1 self.dessin.create_line( p[0] , -p[2] , p0[0] , -p0[2] , fill = 'black' ) # calculer le centre projete de la piste cp = projPtMA ( self.centrePiste , self.centrePiste , \ self.orientation , self.oblicite , \ self.echelleFloat , self.anamorphisme ) # dessiner triangle piste if self.dessinerTrianglePiste == 1 : ptri = projPtMA ( self.pointeTrianglePiste , self.centrePiste , \ self.orientation , self.oblicite , \ self.echelleFloat , self.anamorphisme ) tri = [ pts2[0][0] , -pts2[0][2] , \ pts2[-1][0] , -pts2[-1][2] , \ ptri[0] , -ptri[2] ] self.dessin.create_polygon( tri , fill = 'khaki' ) #'yellow' '#c7e824' # ecrire nom piste if self.ecrireNomPiste == 1 : ctri = projPtMA ( self.centreTrianglePiste , self.centrePiste , \ self.orientation , self.oblicite , \ self.echelleFloat , self.anamorphisme ) self.dessin.create_text( ctri[0] , -ctri[2] , text = self.nomPisteChoisie ) # dessiner le vecteur central de hauteur 100m if self.dessinerVecteur100m == 1 : v = [ self.centrePiste[0] , \ self.centrePiste[1] , \ self.centrePiste[2]+100 ] vp = projPtMA ( v , self.centrePiste , \ self.orientation , self.oblicite , \ self.echelleFloat , self.anamorphisme ) self.dessin.create_line( cp[0] , -cp[2] , vp[0] , -vp[2] , fill = 'black' , arrow = "last" ) # =========================================== def dessinerContour (self) : # =========================================== for c in self.listeToutesInfosAerodromeChoisi[4] : pts = c[0] # points angulaires de la piste pts2 = [] # points projetes ptsPolygonePiste = [] # points ecran # calculer for p in pts : p2 = projPtMA ( p , self.centrePiste , \ self.orientation , self.oblicite , \ self.echelleFloat , self.anamorphisme ) pts2.append ( p2 ) # dessiner la surface du terrain couleurRevetement = '#6a761B' #'darkgreen' for p in pts2 : ptsPolygonePiste.append(p[0]) ptsPolygonePiste.append(-p[2]) self.dessin.create_polygon( ptsPolygonePiste , fill = couleurRevetement ) # =========================================== def dessinerAutresPistePlaneur (self) : # =========================================== for pi in self.listeInfoToutesPistesPlaneur : pts = pi[4] # points angulaires de la piste pts2 = [] # points projetes # calculer for p in pts : p2 = projPtMA ( p , self.centrePiste , \ self.orientation , self.oblicite , \ self.echelleFloat , self.anamorphisme ) pts2.append ( p2 ) # dessiner le contour de la piste p0 , pMoins , i = pts2[0] , pts2[0] , 0 for p in pts2 : if i > 0 : self.dessin.create_line( pMoins[0] , -pMoins[2] , p[0] , -p[2] , fill='black' ) pMoins = p i = i + 1 self.dessin.create_line( p[0] , -p[2] , p0[0] , -p0[2] , fill = 'black' ) # =========================================== def dessinerPisteAvion (self) : # =========================================== for pi in self.listeToutesInfosAerodromeChoisi[6] : pts = pi[4] # points angulaires de la piste pts2 = [] # points projetes # calculer for p in pts : p2 = projPtMA ( p , self.centrePiste , \ self.orientation , self.oblicite , \ self.echelleFloat , self.anamorphisme ) pts2.append ( p2 ) # dessiner le contour de la piste p0 , pMoins , i = pts2[0] , pts2[0] , 0 for p in pts2 : if i > 0 : self.dessin.create_line( pMoins[0] , -pMoins[2] , p[0] , -p[2] , fill='black' ) pMoins = p i = i + 1 self.dessin.create_line( p[0] , -p[2] , p0[0] , -p0[2] , fill = 'black' ) # =========================================== def dessinerPisteAnciennePlaneur (self) : # =========================================== for pi in self.listeToutesInfosAerodromeChoisi[7] : pts = pi[4] # points angulaires de la piste pts2 = [] # points projetes # calculer for p in pts : p2 = projPtMA ( p , self.centrePiste , \ self.orientation , self.oblicite , \ self.echelleFloat , self.anamorphisme ) pts2.append ( p2 ) # dessiner le contour de la piste p0 , pMoins , i = pts2[0] , pts2[0] , 0 for p in pts2 : if i > 0 : self.dessin.create_line( pMoins[0] , -pMoins[2] , p[0] , -p[2] , fill='black' ) pMoins = p i = i + 1 self.dessin.create_line( p[0] , -p[2] , p0[0] , -p0[2] , fill = 'black' ) # =========================================== def dessinerPisteModelisme (self) : # =========================================== for pi in self.listeToutesInfosAerodromeChoisi[8] : pts = pi[4] # points angulaires de la piste pts2 = [] # points projetes # calculer for p in pts : p2 = projPtMA ( p , self.centrePiste , \ self.orientation , self.oblicite , \ self.echelleFloat , self.anamorphisme ) pts2.append ( p2 ) # dessiner le contour de la piste p0 , pMoins , i = pts2[0] , pts2[0] , 0 for p in pts2 : if i > 0 : self.dessin.create_line( pMoins[0] , -pMoins[2] , p[0] , -p[2] , fill='black' ) pMoins = p i = i + 1 self.dessin.create_line( p[0] , -p[2] , p0[0] , -p0[2] , fill = 'black' ) # =========================================== def dessinerTaxiwayPlaneur (self) : # =========================================== for t in self.listeToutesInfosAerodromeChoisi[9] : pts = t[1] # points angulaires du taxiway pts2 = [] # points projetes # calculer for p in pts : p2 = projPtMA ( p , self.centrePiste , \ self.orientation , self.oblicite , \ self.echelleFloat , self.anamorphisme ) pts2.append ( p2 ) # dessiner le contour p0 , pMoins , i = pts2[0] , pts2[0] , 0 for p in pts2 : if i > 0 : self.dessin.create_line( pMoins[0] , -pMoins[2] , p[0] , -p[2] , fill='black' ) pMoins = p i = i + 1 self.dessin.create_line( p[0] , -p[2] , p0[0] , -p0[2] , fill = 'black' ) # =========================================== def dessinerTaxiwayAvion (self) : # =========================================== for t in self.listeToutesInfosAerodromeChoisi[10] : pts = t[1] # points angulaires du taxiway pts2 = [] # points projetes # calculer for p in pts : p2 = projPtMA ( p , self.centrePiste , \ self.orientation , self.oblicite , \ self.echelleFloat , self.anamorphisme ) pts2.append ( p2 ) # dessiner le contour p0 , pMoins , i = pts2[0] , pts2[0] , 0 for p in pts2 : if i > 0 : self.dessin.create_line( pMoins[0] , -pMoins[2] , p[0] , -p[2] , fill='black' ) pMoins = p i = i + 1 self.dessin.create_line( p[0] , -p[2] , p0[0] , -p0[2] , fill = 'black' ) # =========================================== def dessinerVolPrincipal (self) : # =========================================== # calculer pts2 = [] for p in self.pointsLimitesVolPrincipal : p2 = projPtMA ( p , self.centrePiste , self.orientation , \ self.oblicite , self.echelleFloat , self.anamorphisme ) pts2.append ( p2 ) # dessiner if len (pts2) > 0 : p0 ,pMoins , i = pts2[0] , pts2[0] , 0 for p in pts2 : if i > 0 : self.dessin.create_line( pMoins[0] , -pMoins[2] , p[0] , -p[2] , fill = 'orange' , width = 2 ) pMoins = p i = i + 1 # =========================================== def dessinerVolsComparatifs (self) : # =========================================== # calculer listeVols = [] for vol in self.VolsComparatifsLimites : pts2 = [] for p in vol : p2 = projPtMA ( p , self.centrePiste , self.orientation , \ self.oblicite , self.echelleFloat , self.anamorphisme ) pts2.append ( p2 ) listeVols.append (pts2) # dessiner for vol in listeVols : if len (vol) > 0 : p0 ,pMoins , i = vol[0] , vol[0] , 0 for p in vol : if i > 0 : self.dessin.create_line( pMoins[0] , -pMoins[2] , p[0] , -p[2] , fill = 'grey' , width = 1 ) pMoins = p i = i + 1 # =========================================== def dessinerVecteursVent ( self ) : # =========================================== if self.affichageVent == 1 : for vent in self.listeVecteursVent : v = projPtMA ( vent[0] , self.centrePiste , self.orientation ,\ self.oblicite , self.echelleFloat , self.anamorphisme ) w = projPtMA ( vent[1] , self.centrePiste , self.orientation ,\ self.oblicite , self.echelleFloat , self.anamorphisme ) self.dessin.create_line( v[0] , -v[2] , w[0] , -w[2] , fill = 'yellow' , width = 2 , arrow = 'last' ) if self.affichageVitesseVent == 1 : self.dessin.create_text( w[0] , -w[2] , fill='yellow' , text = str(self.vitesseMonoVent)+' Km/h' ) # =========================================== def constituerAnnotationGeneraleVolPrincipal ( self ) : # =========================================== self.annotationGeneVolPrincipal = self.annotGeneVolPrincVar.get() if self.annotationGeneVolPrincipal == 'aucune' or \ self.annotationGeneVolPrincipal == 'none' : self.texteAnnotationGeneraleVolPrincipal = "" elif self.annotationGeneVolPrincipal == 'Nom Fichier' or \ self.annotationGeneVolPrincipal == 'Name of the File' : self.texteAnnotationGeneraleVolPrincipal = \ self.nomFichierVolPrincipal elif self.annotationGeneVolPrincipal == 'Pilote' or \ self.annotationGeneVolPrincipal == 'Pilot' : for ligne in self.fichierBrutVolPrincipal : if ligne [0:12] == 'HFPLTPILOT: ' : self.texteAnnotationGeneraleVolPrincipal = ligne [12:] break elif self.annotationGeneVolPrincipal == 'Planeur' or \ self.annotationGeneVolPrincipal == 'Glider' : for ligne in self.fichierBrutVolPrincipal : if ligne [0:17] == 'HFGTYGLIDERTYPE: ' : self.texteAnnotationGeneraleVolPrincipal = ligne [17:] break elif self.annotationGeneVolPrincipal == 'Immatriculation' or \ self.annotationGeneVolPrincipal == 'Callsign' : for ligne in self.fichierBrutVolPrincipal : if ligne [0:15] == 'HFGIDGLIDERID: ' : self.texteAnnotationGeneraleVolPrincipal = ligne [15:] break elif self.annotationGeneVolPrincipal == 'Date' or \ self.annotationGeneVolPrincipal == 'Date' : for ligne in self.fichierBrutVolPrincipal : if ligne [0:5] == 'HFDTE' : self.texteAnnotationGeneraleVolPrincipal = \ ligne [5:7]+'-'+ligne [7:9]+'-'+ligne [9:] break elif self.annotationGeneVolPrincipal == 'Heure' or \ self.annotationGeneVolPrincipal == 'Hour' : if len (self.pointsLimitesVolPrincipal) > 0 : self.texteAnnotationGeneraleVolPrincipal = \ str(int(self.pointsLimitesVolPrincipal[0][3]))+'h'+ \ str(int(self.pointsLimitesVolPrincipal[0][4])) else : self.texteAnnotationGeneraleVolPrincipal = "" elif self.annotationGeneVolPrincipal == 'Pilote+Immat+Date+heure' or \ self.annotationGeneVolPrincipal == 'Pilot+Callsign+Date+hour' : p , i , d , h = '' , '' , '' , '' for ligne in self.fichierBrutVolPrincipal : if ligne [0:12] == 'HFPLTPILOT: ' : p = ligne [12:] elif ligne [0:15] == 'HFGIDGLIDERID: ' : i = ligne [15:] elif ligne [0:5] == 'HFDTE' : d = ligne [5:7]+'-'+ligne [7:9]+'-'+ligne [9:] if p != '' and i != '' and d != '' : break if len (self.pointsLimitesVolPrincipal) > 0 : h = str(int(self.pointsLimitesVolPrincipal[0][3]))+'h'+ \ str(int(self.pointsLimitesVolPrincipal[0][4])) self.texteAnnotationGeneraleVolPrincipal = \ p+' / '+i+' / '+d+' / '+h else : self.texteAnnotationGeneraleVolPrincipal = "?" # =========================================== def ecrireAnnotationGeneraleVolPrincipal ( self ) : # =========================================== if len (self.pointsLimitesVolPrincipal) > 0 : pointDaffichage = self.pointsLimitesVolPrincipal[-1] p2 = projPtMA ( pointDaffichage , self.centrePiste , \ self.orientation , self.oblicite , self.echelleFloat , \ self.anamorphisme ) self.dessin.create_text( p2[0] , -p2[2] , text = self.texteAnnotationGeneraleVolPrincipal ) # =========================================== def constituerAnnotationIntermediaireVolPrincipal ( self ) : # =========================================== self.annotationInterVolPrincipal = self.annotInterVolPrVar.get() self.pasAnnotInterVolPrincipal = \ self.pasAnnotInterVolPrVar.get () # creer 1 liste des points correspondant au pas listeReduiteAuPas , i = [] , 0 while i < len (self.pointsLimitesVolPrincipal) : listeReduiteAuPas.append( self.pointsLimitesVolPrincipal[i] ) i = i + self.pasAnnotInterVolPrincipal # determiner l annotation if self.annotationInterVolPrincipal == 'aucune' or \ self.annotationInterVolPrincipal == 'none' : self.listeAnnotIntermediaireVolPrincipal = [] elif self.annotationInterVolPrincipal == 'Vitesse Galileenne (Km/h)'or\ self.annotationInterVolPrincipal == 'Galilean Speed (Km/h)' : self.listeAnnotIntermediaireVolPrincipal = [] if len(listeReduiteAuPas) > 0 : pm = listeReduiteAuPas[0] for p in listeReduiteAuPas : dLat = (p[0]-pm[0])*1852*60 dLon = (math.cos(self.centrePiste[0]*math.pi/180)* \ (p[1]-pm[1]))*1852*60 dhau = p[2]-pm[2] d = ( (dLat**2) + (dLon**2) + (dhau**2) )**0.5 t = (p[3]-pm[3])*3600 + (p[4]-pm[4])*60 + (p[5]-pm[5]) if t != 0 : v = 3.6 * ( d / t ) vStr = str ( int ( v ) ) if self.uniteAnnotInterVolPrincipal == 1 : vStr = vStr + ' Km/h' else : vStr = '-' p2 = [(p[0]+pm[0])/2,(p[1]+pm[1])/2,(p[2]+pm[2])/2, \ p[3],p[4],p[5],vStr] self.listeAnnotIntermediaireVolPrincipal.append ( p2 ) pm = p elif self.annotationInterVolPrincipal == 'Vitesse Relative (Km/h)' or \ self.annotationInterVolPrincipal == 'Air Speed (Km/h)' : self.listeAnnotIntermediaireVolPrincipal = [] if len(listeReduiteAuPas) > 0 : pm = listeReduiteAuPas[0] for p in listeReduiteAuPas : t = (p[3]-pm[3])*3600 + (p[4]-pm[4])*60 + (p[5]-pm[5]) if self.modeDefinitionDuVent == 'Nul' or \ self.modeDefinitionDuVent == 'No' : dLat = (p[0]-pm[0])*1852*60 dLon = (math.cos(self.centrePiste[0]*math.pi/180)* \ (p[1]-pm[1]))*1852*60 dhau = p[2]-pm[2] d = ( (dLat**2) + (dLon**2) + (dhau**2) )**0.5 if self.modeDefinitionDuVent == 'Definir' or \ self.modeDefinitionDuVent == 'Define' : vMVkts = 1.0 * self.vitesseMonoVent / 1.852 dMV = 1.0 * self.directionMonoVent pmD = [pm[0] - vMVkts/60*t/3600*math.cos(dMV*math.pi/180),\ pm[1] + vMVkts/60*t/3600*math.sin(dMV*math.pi/180) \ / math.cos(pm[0]*math.pi/180) , \ pm[2] ] dLat = (p[0]-pmD[0])*1852*60 dLon = (math.cos(self.centrePiste[0]*math.pi/180)* \ (p[1]-pmD[1]))*1852*60 dhau = p[2]-pmD[2] d = ( (dLat**2) + (dLon**2) + (dhau**2) )**0.5 if t != 0 : v = 3.6 * ( d / t ) vStr = str ( int ( v ) ) if self.uniteAnnotInterVolPrincipal == 1 : vStr = vStr + ' Km/h' else : vStr = '-' p2 = [(p[0]+pm[0])/2,(p[1]+pm[1])/2,(p[2]+pm[2])/2, \ p[3],p[4],p[5],vStr] self.listeAnnotIntermediaireVolPrincipal.append ( p2 ) pm = p elif self.annotationInterVolPrincipal == 'Vario (m/s)' or \ self.annotationInterVolPrincipal == 'Vario (m/s)' : if len(listeReduiteAuPas) > 0 : pm = listeReduiteAuPas[0] self.listeAnnotIntermediaireVolPrincipal = [] for p in listeReduiteAuPas : dhau = p[2]-pm[2] t = (p[3]-pm[3])*3600 + (p[4]-pm[4])*60 + (p[5]-pm[5]) if t != 0 : vario = dhau / t vStr = str ( int ( vario ) ) if self.uniteAnnotInterVolPrincipal == 1 : vStr = vStr + ' m/s' else : vStr = '-' p2 = [(p[0]+pm[0])/2,(p[1]+pm[1])/2,(p[2]+pm[2])/2, \ p[3],p[4],p[5],vStr] self.listeAnnotIntermediaireVolPrincipal.append ( p2 ) pm = p elif self.annotationInterVolPrincipal == 'Angle (deg)' : # or self.listeAnnotIntermediaireVolPrincipal = [] if len(listeReduiteAuPas) > 0 : pm = listeReduiteAuPas[0] for p in listeReduiteAuPas : dLat = (p[0]-pm[0])*1852*60 dLon = (math.cos(self.centrePiste[0]*math.pi/180)* \ (p[1]-pm[1]))*1852*60 dhau = p[2]-pm[2] dhoriz = ( (dLat**2) + (dLon**2) )**0.5 if dhoriz != 0 : ang = 180.0/math.pi*math.atan( dhau / dhoriz ) angStr = str ( int ( ang ) ) if self.uniteAnnotInterVolPrincipal == 1 : angStr = angStr + ' deg' else : angStr = '-' p2 = [(p[0]+pm[0])/2,(p[1]+pm[1])/2,(p[2]+pm[2])/2, \ p[3],p[4],p[5],angStr] self.listeAnnotIntermediaireVolPrincipal.append ( p2 ) pm = p elif self.annotationInterVolPrincipal == 'Hauteur (m)' or \ self.annotationInterVolPrincipal == 'High (m)' : self.listeAnnotIntermediaireVolPrincipal = [] for p in listeReduiteAuPas : h = p[2]-self.centrePiste[2] hStr = str(int(h)) if self.uniteAnnotInterVolPrincipal == 1 : hStr = hStr + ' m' p2 = [p[0],p[1],p[2],p[3],p[4],p[5], hStr ] self.listeAnnotIntermediaireVolPrincipal.append ( p2 ) elif self.annotationInterVolPrincipal == 'Altitude (m)' or \ self.annotationInterVolPrincipal == 'Altitude (m)' : self.listeAnnotIntermediaireVolPrincipal = [] for p in listeReduiteAuPas : a = p[2] aStr = str(int(a)) if self.uniteAnnotInterVolPrincipal == 1 : aStr = aStr + ' m' p2 = [p[0],p[1],p[2],p[3],p[4],p[5], aStr ] self.listeAnnotIntermediaireVolPrincipal.append ( p2 ) elif self.annotationInterVolPrincipal == 'Chrono (s)' or \ self.annotationInterVolPrincipal == 'Stopwatch (s)' : self.listeAnnotIntermediaireVolPrincipal = [] if len(listeReduiteAuPas) > 0 : p0 = listeReduiteAuPas[0] t0 = p0[3]*3600 + p0[4]*60 + p0[5] else : t0 = 0 for p in listeReduiteAuPas : t = p[3]*3600 + p[4]*60 + p[5] chrono = t - t0 cStr = str(int(chrono)) if self.uniteAnnotInterVolPrincipal == 1 : cStr = cStr + ' s' p2 = [p[0],p[1],p[2],p[3],p[4],p[5], cStr ] self.listeAnnotIntermediaireVolPrincipal.append ( p2 ) elif self.annotationInterVolPrincipal == 'Energie massique (J/Kg)' or \ self.annotationInterVolPrincipal == 'Energy to Mass (J/Kg)' : self.listeAnnotIntermediaireVolPrincipal = [] if len(listeReduiteAuPas) > 0 : pm = listeReduiteAuPas[0] for p in listeReduiteAuPas : dLat = (p[0]-pm[0])*1852*60 dLon = (math.cos(self.centrePiste[0]*math.pi/180)* \ (p[1]-pm[1]))*1852*60 dhau = p[2]-pm[2] d = ( (dLat**2) + (dLon**2) + (dhau**2) )**0.5 t = (p[3]-pm[3])*3600 + (p[4]-pm[4])*60 + (p[5]-pm[5]) if t != 0 : Ecm = ( d / t )**2 else : Ecm = 0 Epm = 9.81*(p[2]-self.centrePiste[2]) Etm = Ecm + Epm EtmStr = str(int(Etm)) if self.uniteAnnotInterVolPrincipal == 1 : EtmStr = EtmStr + ' J/Kg' p2 = [(p[0]+pm[0])/2,(p[1]+pm[1])/2,(p[2]+pm[2])/2, \ p[3],p[4],p[5], EtmStr ] self.listeAnnotIntermediaireVolPrincipal.append ( p2 ) pm = p elif self.annotationInterVolPrincipal == 'Puissance massique (W/Kg)'or\ self.annotationInterVolPrincipal == 'Power to Mass (W/Kg)' : self.listeAnnotIntermediaireVolPrincipal = [] if len(listeReduiteAuPas) > 0 : pm , Etmm = listeReduiteAuPas[0] , 0 for p in listeReduiteAuPas : dLat = (p[0]-pm[0])*1852*60 dLon = (math.cos(self.centrePiste[0]*math.pi/180)* \ (p[1]-pm[1]))*1852*60 dhau = p[2]-pm[2] d = ( (dLat**2) + (dLon**2) + (dhau**2) )**0.5 t = (p[3]-pm[3])*3600 + (p[4]-pm[4])*60 + (p[5]-pm[5]) if t != 0 : Ecm = ( d / t )**2 else : Ecm = 0 Epm = 9.81*(p[2]-self.centrePiste[2]) Etm = Ecm + Epm if t != 0 : Ptm = ( Etm - Etmm ) / t else : Ptm = 0 PtmStr = str(int(Ptm)) if self.uniteAnnotInterVolPrincipal == 1 : PtmStr = PtmStr + ' W/Kg' p2 = [(p[0]+pm[0])/2,(p[1]+pm[1])/2,(p[2]+pm[2])/2, \ p[3],p[4],p[5],PtmStr] self.listeAnnotIntermediaireVolPrincipal.append ( p2 ) pm , Etmm = p , Etm elif self.annotationInterVolPrincipal == \ 'Puissance massique (ch/quintal)' or \ self.annotationInterVolPrincipal == \ 'Power to Mass (hp/100Kg)' : self.listeAnnotIntermediaireVolPrincipal = [] if len(listeReduiteAuPas) > 0 : pm , Etmm = listeReduiteAuPas[0] , 0 for p in listeReduiteAuPas : dLat = (p[0]-pm[0])*1852*60 dLon = (math.cos(self.centrePiste[0]*math.pi/180)* \ (p[1]-pm[1]))*1852*60 dhau = p[2]-pm[2] d = ( (dLat**2) + (dLon**2) + (dhau**2) )**0.5 t = (p[3]-pm[3])*3600 + (p[4]-pm[4])*60 + (p[5]-pm[5]) if t != 0 : Ecm = ( d / t )**2 else : Ecm = 0 Epm = 9.81*(p[2]-self.centrePiste[2]) Etm = Ecm + Epm if t != 0 : Ptm = 100.0/736*( Etm - Etmm ) / t else : Ptm = 0 PtmStr = str(int(Ptm)) if self.uniteAnnotInterVolPrincipal == 1 : if self.annotationInterVolPrincipal == \ 'Puissance massique (ch/quintal)' : PtmStr = PtmStr + ' ch/quintal' elif self.annotationInterVolPrincipal == \ 'Power to Mass (hp/100Kg)' : PtmStr = PtmStr + ' hp/100Kg' p2 = [(p[0]+pm[0])/2,(p[1]+pm[1])/2,(p[2]+pm[2])/2, \ p[3],p[4],p[5],PtmStr] self.listeAnnotIntermediaireVolPrincipal.append ( p2 ) pm , Etmm = p , Etm else : self.listeAnnotIntermediaireVolPrincipal = [] # =========================================== def ecrireAnnotationIntermediaireVolPrincipal ( self ) : # =========================================== # Cas dans lequel le vent intervient : Ecrire en jaune if ( self.annotationInterVolPrincipal == 'Vitesse Relative (Km/h)' or \ self.annotationInterVolPrincipal == 'Air Speed (Km/h)' ) and \ ( self.modeDefinitionDuVent == 'Definir' or \ self.modeDefinitionDuVent == 'Define' ) : for p in self.listeAnnotIntermediaireVolPrincipal : p2 = projPtMA ( p , self.centrePiste , self.orientation , \ self.oblicite , self.echelleFloat , self.anamorphisme ) self.dessin.create_text( p2[0] , -p2[2] , text = str(p[6]) ,\ fill = 'yellow' ) # Cas general ecriture standard else : for p in self.listeAnnotIntermediaireVolPrincipal : p2 = projPtMA ( p , self.centrePiste , self.orientation , \ self.oblicite , self.echelleFloat , self.anamorphisme ) self.dessin.create_text( p2[0] , -p2[2] , text = str(p[6]) ) ########################################################################### class FichierOuvrir : ########################################################################### def __init__( self , parent , categorie , cheminHome , cheminDossier , titreFenetre ): # acquisition des variables pour l'objet fenetre cree self.parent = parent self.categorie = categorie self.cheminHome = cheminHome self.cheminDossier = cheminDossier self.titreFenetre = titreFenetre # Creer la fenetre self.fenetre = Pmw.MegaToplevel(title = self.titreFenetre ) self.contenant = self.fenetre.interior() # Rechercher les fichiers contenus dans le dossier os.chdir ( self.cheminHome ) os.chdir ( self.cheminDossier ) self.listeFichiers = os.listdir( '.' ) self.listeFichiers.sort () self.listeFichiers.reverse() # Creer la liste deroulante self.listeDeroulante = Pmw.ScrolledListBox ( self.contenant , items = self.listeFichiers , labelpos = 'nw' , label_text = 'Fichiers disponibles' , usehullsize = 1 , hull_width = 300 , hull_height = 400 , selectioncommand = self.selectionCommande ) self.listeDeroulante.pack( fill = 'both', expand = 1, padx = 5, pady = 2) ####################################################################### def selectionCommande (self) : ####################################################################### # recuperer le fichier selectionner self.selection = self.listeDeroulante.getcurselection() if self.categorie == 'principal' : # transmettre le nom du fichier self.parent.nomFichierVolPrincipal = self.selection[0] # lire le fichier os.chdir ( self.cheminHome ) os.chdir ( self.cheminDossier ) f = open ( self.selection[0] , 'r' ) self.parent.fichierBrutVolPrincipal = f.readlines() f.close() # extrire les lignes utiles listeLignesCoordonees = extco(self.parent.fichierBrutVolPrincipal) # effacer le fichier vol principal self.parent.pointsVolPrincipal = [] # reconsituer le fichier vol principal for ligne in listeLignesCoordonees : ligneEnForme = decortili (ligne) self.parent.pointsVolPrincipal.append(ligneEnForme) elif self.categorie == 'comparatif' : # transmettre le nom du fichier self.parent.nomsVolsComparatifs.append ( self.selection[0] ) # lire le fichier os.chdir ( self.cheminHome ) os.chdir ( self.cheminDossier ) f = open ( self.selection[0] , 'r' ) volBrut = f.readlines() f.close() # extrire les lignes utiles listeLignesCoordonees = extco( volBrut ) # initialiser le vol comparatif additionnel volLimiteAuxPts = [] # consituer le vol comparatif additionnel for ligne in listeLignesCoordonees : ligneEnForme = decortili (ligne) volLimiteAuxPts.append(ligneEnForme) # transmettre en l ajoutant le vol comparatif additionnel self.parent.VolsComparatifs.append( volLimiteAuxPts ) # Re calculer et changer la vue self.parent.calculerValeursDeBase () self.parent.redessinerTout () # fermer la fenetre self.fenetre.destroy() ########################################################################### class FenetreTexte : ########################################################################### def __init__ ( self , parent , titreFenetre , texte , hauteur , largeur ) : self.parent = parent self.titreFenetre = titreFenetre self.texte = texte self.hauteur = hauteur self.largeur = largeur self.fenetre = Pmw.MegaToplevel( title = str(titreFenetre) ) self.contenant = self.fenetre.interior() self.zoneTexte = ZoneTexteAscenceurs(self.contenant , self.texte , self.hauteur , self.largeur ) self.zoneTexte.pack( fill = 'both', expand = 1 ) ########################################################################### class ZoneTexteAscenceurs(Pmw.ScrolledText) : ########################################################################### def __init__ ( self , contenant , texte , hauteur , largeur ) : self.contenant = contenant self.texte = texte self.hauteur = hauteur self.largeur = largeur Pmw.ScrolledText.__init__( self , contenant , borderframe = 1 , usehullsize = 1 , hull_width = self.largeur , hull_height = self.hauteur ) self.configure( vscrollmode = 'dynamic' , hscrollmode = 'dynamic' ) self.appendtext(self.texte) ########################################################################### class DefinirMonoVent : ########################################################################### def __init__( self , parent , titreFenetre , direction , vitesse , nomPourDirection , nomPourVitesse , nomPourOK , nomPourAnnuler , nomPourVisualiser ): # acquisition des variables pour l'objet fenetre cree self.parent = parent self.titreFenetre = titreFenetre self.direction = direction self.vitesse = vitesse self.nomPourDirection = nomPourDirection self.nomPourVitesse = nomPourVitesse self.nomPourOK = nomPourOK self.nomPourAnnuler = nomPourAnnuler self.nomPourVisualiser = nomPourVisualiser # Creer la fenetre self.fenetre = Pmw.MegaToplevel(title = self.titreFenetre ) self.contenant = self.fenetre.interior() # Creer les champs self.champVitesse = Pmw.Counter ( self.contenant , labelpos = 'n' , label_text = self.nomPourVitesse , entryfield_value = self.vitesse , increment = 5 , entryfield_command = self.acquerirVitesse , entryfield_validate = {'validator':'numeric' , 'min':0 , 'max':200 } ) self.champDirection = Pmw.Counter ( self.contenant , labelpos = 'n' , label_text = self.nomPourDirection , entryfield_value = self.direction , increment = 10 , entryfield_command = self.acquerirDirection , entryfield_validate = {'validator':'numeric' , 'min':0 , 'max':360 } ) # Creer les bouttons self.boiteAboutons = Pmw.ButtonBox ( self.contenant , labelpos = 'nw' , frame_borderwidth = 2 , frame_relief = 'groove' ) self.boiteAboutons.add ( self.nomPourOK , command = self.ok ) self.boiteAboutons.add ( self.nomPourAnnuler , command = self.annuler ) self.boiteAboutons.add ( self.nomPourVisualiser,command=self.visualise) # placer les champs self.champVitesse.pack (side='top' , fill='x' , expand=0 , padx=10 , pady=5) self.champDirection.pack( side='top' , fill='x' , expand=0 , padx=10 , pady=5) # placer les bouttons self.boiteAboutons.pack (side='top' , fill='none' , expand=0 , padx=5 , pady=5) def acquerirVitesse ( self ) : self.vitesseA = self.champVitesse.get() self.parent.vitesseMonoVentVar.set(self.vitesseA) # recalculer et redessiner self.parent.calculerValeursDeBase () self.parent.redessinerTout () def acquerirDirection ( self ) : self.directionA = self.champDirection.get() self.parent.directionMonoVentVar.set(self.directionA) # recalculer et redessiner self.parent.calculerValeursDeBase () self.parent.redessinerTout () def ok ( self ) : # recuperer les reglages self.vitesseA = self.champVitesse.get () self.directionA = self.champDirection.get() # modifier les variables de transfert self.parent.vitesseMonoVentVar.set (self.vitesseA ) self.parent.directionMonoVentVar.set(self.directionA) # modifier les variables normales self.parent.vitesseMonoVent = self.vitesseA self.parent.directionMonoVent = self.directionA # fermer self.fenetre.destroy() # recalculer et redessiner self.parent.calculerValeursDeBase () self.parent.redessinerTout () def annuler ( self ) : # recuperer les reglages initiaux self.parent.vitesseMonoVentVar.set (self.vitesse ) self.parent.directionMonoVentVar.set(self.direction) self.parent.vitesseMonoVent = self.vitesse self.parent.directionMonoVent = self.direction # fermer self.fenetre.destroy() # recalculer et redessiner self.parent.calculerValeursDeBase () self.parent.redessinerTout () def visualise ( self ) : # recuperer les reglages self.vitesseA = self.champVitesse.get () self.directionA = self.champDirection.get() # modifier les variables de transfert self.parent.vitesseMonoVentVar.set (self.vitesseA ) self.parent.directionMonoVentVar.set(self.directionA) # recalculer et redessiner self.parent.calculerValeursDeBase () self.parent.redessinerTout () #####=====#####=====#####=====#####=====#####=====#####=====#####=====##### #####=================================================================##### ##### P R O G R A M M E ##### #####=================================================================##### #####=====#####=====#####=====#####=====#####=====#####=====#####=====##### if __name__ == '__main__' : # Recuperation de donnees fondamentales dossierHome = os.environ['HOME'] try : langSys = os.environ['LANGUAGE'] # 'fr_FR:fr:en_GB:en' except KeyError , libelle : try : langSys = os.environ['LANG'] # 'fr_FR.UTF-8' except KeyError , libelle : langSys = 'en_GB:en:en_GB:en' else : pass else : pass # Determination de la langue par defaut langP = 'en' if langSys [:2] == 'fr' or langSys [3:5] == 'FR' : langP = 'fr' # Fichiers par defaut terrainBelfort = ['# apoglide # Aerodrome Francais # Belfort-Chaux #', \ '##################################################', \ 'format_aero,apoglide2008-01,', \ 'nom,Belfort-Chaux,', \ 'pays,France,', \ 'contour,47.695,-6.8322,410,47.6961,-6.835,410,47.6997,-6.835,410,47.7047,-6.8358,415,47.7056,-6.8336,420,47.7056,-6.8283,420,47.6989,-6.8275,420,',\ 'pistePlaneur,18G,herbe,36D,180,47.705,-6.8319,419,47.697,-6.8324,412,47.697,-6.8313,412,47.705,-6.8308,419,',\ 'pistePlaneur,36D,herbe,18G,000,47.697,-6.8313,412,47.705,-6.8308,419,47.705,-6.8319,419,47.697,-6.8324,412,',\ '#pisteAnciennePlaneur,',\ '#pisteSecondairePlaneur,',\ '#pisteMixte,',\ 'pisteAncienneMixte,04,herbe,22,040,47.6989,-6.8283,420,47.7047,-6.8342,420,47.7042,-6.8353,420,47.6981,-6.8294,420,',\ 'pisteAncienneMixte,22,herbe,04,220,47.7042,-6.8353,420,47.6981,-6.8294,420,47.6989,-6.8283,420,47.7047,-6.8342,420,',\ '#pisteSecondaireMixte,',\ '#pisteVolLibre,',\ '#pisteAncienneVolLibre,',\ '#pisteSecondaireVolLibre,',\ 'pisteAvion,18D,herbe,36G,180,47.705,-6.8302,419,47.697,-6.8306,412,47.697,-6.8313,412,47.705,-6.8308,419,',\ 'pisteAvion,36G,herbe,18D,000,47.697,-6.8313,412,47.705,-6.8308,419,47.705,-6.8302,419,47.697,-6.8306,412,',\ '#pisteAncienneAvion,',\ '#pisteSecondaireAvion,',\ '#pisteULM,',\ '#pisteAncienneULM,',\ '#pisteSecondaireULM,',\ '#aireAerostation,',\ '#aireAncienneAerostation,',\ '#aireSecondaireAerostation,',\ '#aireSpecifique,',\ '#aireAncienneSpecifique,',\ '#aireSecondaireSpecifique,',\ 'pisteModelisme,23M,asphalte,05M,240,47.6983,-6.8333,416,47.6979,-6.8329,416,47.6978,-6.8331,416,47.6982,-6.8335,416,',\ 'pisteModelisme,05M,asphalte,23M,240,47.6978,-6.8331,416,47.6982,-6.8335,416,47.6983,-6.8333,416,47.6979,-6.8329,416,',\ '#pisteAncienneModelisme,',\ '#pisteSecondaireModelisme,',\ '#taxiwayPlaneur,',\ '#taxiwayAncienPlaneur,',\ '#taxiwayMixte,',\ '#taxiwayAncienMixte,',\ 'taxiwayAvion,herbe,47.705,-6.8302,419,47.697,-6.8306,412,47.697,-6.8302,412,47.705,-6.8298,419,',\ '#taxiwayAncienAvion,',\ '#taxiwayULM,',\ '#taxiwayAncienULM,',\ 'treuil,18G,47.697,-6.8316,410,',\ 'treuil,36D,47.705,-6.8311,420,',\ 'mancheAair,48.6979,-6.8335,416,',\ '#aireAsignaux,',\ '#tourControleFixe,',\ '#tourControlePiste,',\ '#starterPiste,',\ '#parkingPlaneur,',\ '#parkingMixte,',\ '#parkingVolLibre,',\ '#parkingAvion,',\ '#parkingULM,',\ '#HangarPlaneur,',\ '#HangarMixte,',\ '#HangarVolLibre,',\ '#HangarAvion,',\ '#HangarULM,' ] terrainBietigheim = ['# apoglide # Deutsche Flugplatz # Bietigheim-Lochgau #', \ '#######################################################', \ 'format_aero,apoglide2008-01,', \ 'nom,Bietigheim-Lochgau,', \ 'pays,Deutschland,', \ 'contour,49.0016,-9.0769,275,49.0001,-9.0802,272,49.0009,-9.0804,270,49.0003,-9.0866,265,49.0006,-9.0867,264,49.0013,-9.082,267,49.00115,-9.0911,264,49.001,-9.0924,265,49.002,-9.0928,262,49.0018,-9.089,262,49.00133,-9.0889,262,49.00145,-9.0813,267,49.0022,-9.0776,272,', \ 'pistePlaneur,09,asphalte,27L,90,49.00146,-9.078,270,49.00125,-9.092,264,49.00119,-9.092,264,49.00139,-9.078,270,', \ 'pistePlaneur,27L,asphalte,09,270,49.00119,-9.092,264,49.00139,-9.078,270,49.00146,-9.078,270,49.00125,-9.092,264,', \ 'pistePlaneur,27R,herbe,09L,270,49.0018,-9.0926,262,49.0018,-9.089,262,49.0013,-9.089,262,49.0013,-9.0925,264,', \ 'pistePlaneur,10,herbe,28,100,49.0015,-9.0806,268,49.0006,-9.0867,264,49.0003,-9.0866,265,49.0011,-9.0805,268,', \ 'pistePlaneur,28,herbe,10,280,49.0003,-9.0866,265,49.0011,-9.0805,268,49.0015,-9.0806,268,49.0006,-9.0867,264,'] terrainChalonsSurMarne = ['# apoglide # Aerodrome Francais # Chalons-Ecury #', \ '##################################################', \ 'format_aero,apoglide2008-01,', \ 'nom,Chalons-Ecury,', \ 'pays,France,', \ 'contour,48.9005,-4.3421,90,48.9033,-4.3448,88,48.9039,-4.3463,87,48.9114,-4.3544,86,48.9094,-4.3586,96,48.8981,-4.3461,97,', \ 'pistePlaneur,22planeur,herbe,04planeur,220,48.9092,-4.3583,96,48.8983,-4.3461,96,48.8988,-4.3453,94,48.9097,-4.3575,94,', \ 'pistePlaneur,04planeur,herbe,22planeur,040,48.8988,-4.3453,94,48.9097,-4.3575,94,48.9092,-4.3583,96,48.8983,-4.3461,96,', \ 'treuil,22planeur,48.8985,-4.3457,95,', \ 'treuil,04planeur,48.9095,-4.3579,95,', \ 'pisteAvion,22avion,herbe,04avion,220,48.91,-4.3566,92,48.8992,-4.3444,92,48.8988,-4.3453,94,48.9097,-4.3575,94,', \ 'pisteAvion,04avion,herbe,22avion,040,48.8988,-4.3453,94,48.9097,-4.3575,94,48.91,-4.3566,92,48.8992,-4.3444,92,'] terrainStFlorentin = ['# apoglide # Aerodrome Francais # Saint-Florentain-Cheu #', \ '##########################################################', \ 'format_aero,apoglide2008-01,', \ 'nom,Saint-Florentain-Cheu,', \ 'pays,France,', \ 'contour,47.9802,-3.7681,102,47.9806,-3.7698,102,47.9818,-3.7706,103,47.9814,-3.7729,103,47.9848,-3.7749,104,47.9846,-3.7766,102,47.9839,-3.7763,101,47.9823,-3.7774,103,47.9831,-3.78245,104,47.98213,-3.7828,103,47.9807,-3.7825,103,47.9778,-3.769,102,', \ 'pistePlaneur,24G,herbe,06D,240,47.9814,-3.7825,102,47.9786,-3.7689,102,47.9792,-3.7686,102,47.9820,-3.7822,102,', \ 'pistePlaneur,06D,herbe,24G,060,47.9792,-3.7686,102,47.9820,-3.7822,102,47.9814,-3.7825,102,47.9786,-3.7689,102,', \ 'pisteAvion,24D,herbe,06G,240,47.98213,-3.7828,103,47.9792,-3.7686,102,47.98,-3.7682,102,47.98295,-3.7824,104,', \ 'pisteAvion,06G,herbe,24D,060,47.98,-3.7682,102,47.98295,-3.7824,104,47.98213,-3.7828,103,47.9792,-3.7686,102,'] volMarc = ['AXXXCUZ Cumulus Soaring Flightcomputer, flightnumber 3',\ 'HFDTE241007','HFFXA500','HFPLTPILOT: Marc Archambault',\ 'HFGTYGLIDERTYPE: ASK-21','HFGIDGLIDERID: F-CBDY',\ 'HFDTM100GPSDATUM: WSG-1984','HFRFWFIRMWAREVERION: 1.3.1-r1',\ 'HFRHWHARDWAREVERSION: : HP iPAQ H3900',\ 'HFFTYFRTYPE: Cumulus for Qt/E, version 1.3.1-r1',\ 'HSCIDCOMPETITIONID: ',\ 'B1607104741806N00649958EA0040600454',\ 'B1607114741818N00649966EA0040700455',\ 'B1607124741829N00649972EA0040800456',\ 'B1607134741840N00649978EA0040900457',\ 'B1607154741863N00649986EA0041100459',\ 'B1607174741889N00649981EA0042100469',\ 'B1607184741900N00649979EA0042900477',\ 'B1607194741909N00649978EA0043700485',\ 'B1607214741929N00649981EA0045400502',\ 'B1607224741939N00649982EA0046400512',\ 'B1607234741949N00649983EA0047500522',\ 'B1607244741961N00649984EA0048600534',\ 'B1607254741974N00649984EA0049900547',\ 'B1607274742001N00649985EA0052900577',\ 'B1607284742015N00649986EA0054600594',\ 'B1607304742045N00649985EA0057700625',\ 'B1607314742060N00649986EA0058900637',\ 'B1607324742075N00649987EA0060100649',\ 'B1607334742091N00649988EA0061400662',\ 'B1607344742106N00649989EA0062500673',\ 'B1607354742121N00649990EA0063600684',\ 'B1607364742135N00649991EA0064600694',\ 'B1607374742148N00649992EA0065700705',\ 'B1607394742172N00649993EA0067700725',\ 'B1607404742184N00649993EA0069600744',\ 'B1607424742205N00649993EA0072300771',\ 'B1607434742216N00649992EA0074300791',\ 'B1607444742225N00649991EA0076100809',\ 'B1607454742234N00649990EA0077400822',\ 'B1607464742243N00649988EA0078600834',\ 'B1607474742254N00649985EA0079600843',\ 'B1607484742264N00649980EA0080400852',\ 'B1607494742274N00649974EA0081000858',\ 'B1607514742293N00649957EA0081800866',\ 'B1607524742302N00649945EA0082000868',\ 'B1607544742318N00649916EA0082000868',\ 'B1607554742325N00649899EA0081800866',\ 'B1607564742333N00649881EA0081600864',\ 'B1607584742347N00649841EA0080800856',\ 'B1607594742354N00649820EA0080400852',\ 'B1608004742361N00649801EA0080100849',\ 'B1608014742369N00649782EA0080000848',\ 'B1608034742385N00649745EA0079800845',\ 'B1608044742392N00649727EA0079600844',\ 'B1608054742399N00649708EA0079500843',\ 'B1608064742407N00649690EA0079400842',\ 'B1608074742414N00649672EA0079400842',\ 'B1608084742421N00649654EA0079300841',\ 'B1608104742436N00649618EA0079400842',\ 'B1608114742444N00649601EA0079300841',\ 'B1608134742460N00649569EA0079200840',\ 'B1608144742470N00649555EA0079100838',\ 'B1608154742481N00649544EA0079000837',\ 'B1608164742492N00649537EA0078800836',\ 'B1608174742503N00649535EA0078700835',\ 'B1608184742514N00649537EA0078500833',\ 'B1608194742523N00649542EA0078500833',\ 'B1608204742530N00649551EA0078400832',\ 'B1608224742537N00649576EA0078300831',\ 'B1608234742539N00649590EA0078300831',\ 'B1608244742539N00649604EA0078200830',\ 'B1608254742537N00649618EA0078200830',\ 'B1608274742523N00649644EA0078200830',\ 'B1608284742512N00649653EA0078200830',\ 'B1608294742500N00649660EA0078100829',\ 'B1608304742487N00649665EA0078000828',\ 'B1608314742473N00649666EA0078000828',\ 'B1608324742458N00649665EA0078000828',\ 'B1608344742429N00649654EA0077700825',\ 'B1608354742414N00649644EA0077500823',\ 'B1608364742400N00649629EA0077300821',\ 'B1608374742388N00649610EA0077200820',\ 'B1608384742376N00649590EA0077000818',\ 'B1608394742366N00649567EA0076900817',\ 'B1608404742357N00649543EA0076900817',\ 'B1608414742350N00649518EA0076900817',\ 'B1608424742346N00649494EA0076900816' ] prefdef = ['# apoglide - preferences',\ '#########################',\ '',\ 'format_preferences,apoglide2008-01,[format],',\ '',\ 'langage,'+langP+',[language],',\ '',\ 'largueur du graphe,950,[graph width],',\ 'hauteur du graphe,630,[graph heigh],',\ 'echelle (pix/m),1,[scale (pixel/m)],',\ 'coeficient d anamorphisme vertical,1,[vertical scale over factor],',\ 'oblicite initiale,10,[vertical deviation angle at startup],',\ '',\ 'dessiner triangle de sens piste,1,[runway direction triangle drawing],',\ 'ecrire nom piste,1,[runway name writing],',\ 'dessiner vecteur vertical 100 m,1,[vertical vector drawing (high=100m)],',\ '',\ 'aerodrome initial,Belfort-Chaux,[startup airfield],', 'piste initiale,18G,[startup runway],', '',\ 'annotation generale du vol principal,Nom Fichier,[general indication of main flight],',\ 'annotation intermediaire du vol principal,aucune,[intermediate indication of main flight],',\ 'pas d annotation intermediaire,2,[intermediate indication step],' ] # Verification de l'arborescance os.chdir(os.environ['HOME']) if os.path.isdir('apoglide') == False : os.mkdir('apoglide') os.chdir('apoglide') if os.path.isdir('aerodromes') == False and \ os.path.isdir('airfields') == False and \ os.path.isdir('flugplatz') == False : os.mkdir('aerodromes') os.chdir('aerodromes') f = open ( 'Belfort-Chaux.txt' , 'w' ) for l in terrainBelfort : f.write(l) f.write('\n') f.close() f = open ( 'Bietigheim-Lochgau.txt' , 'w' ) for l in terrainBietigheim : f.write(l) f.write('\n') f.close() f = open ( 'Chalons-Ecury.txt' , 'w' ) for l in terrainChalonsSurMarne : f.write(l) f.write('\n') f.close() f = open ( 'Saint-Florentin-Cheu.txt' , 'w' ) for l in terrainStFlorentin : f.write(l) f.write('\n') f.close() os.chdir('..') else : if os.path.isdir('aerodromes') == True : os.chdir('aerodromes') elif os.path.isdir('airfields' ) == True : os.chdir('airfields' ) elif os.path.isdir('flugplatz' ) == True : os.chdir('flugplatz' ) if len(os.listdir('.')) == 0 : f = open ( 'Belfort-Chaux.txt' , 'w' ) for l in terrainBelfort : f.write(l) f.write('\n') f.close() os.chdir('..') if os.path.isdir('enregistrements GPS') == False : os.mkdir('enregistrements GPS') os.chdir('enregistrements GPS') f = open ( '2007-10-24_Archi' , 'w' ) for l in volMarc : f.write(l) f.write('\n') f.close() os.chdir('..') if os.path.isdir('Preferences') == False : os.mkdir('Preferences') os.chdir('Preferences') f = open ( 'preferences.txt' , 'w' ) for l in prefdef : f.write(l) f.write('\n') f.close() os.chdir('..') else : os.chdir('Preferences') if os.path.isfile('preferences.txt') == False : f = open ( 'preferences.txt' , 'w' ) for l in prefdef : f.write(l) f.write('\n') f.close() os.chdir('..') os.chdir(os.environ['HOME']) # lire les preferences listePreferences = recupererPreferences (dossierHome , 'apoglide/Preferences') formatPrefD = listePreferences[ 0] langageD = listePreferences[ 1] xGrapheD = listePreferences[ 2] yGrapheD = listePreferences[ 3] echelleD = listePreferences[ 4] anamorphismeD = listePreferences[ 5] obliciteD = listePreferences[ 6] dessinerTrianglePisteD = listePreferences[ 7] ecrireNomPisteD = listePreferences[ 8] dessinerVecteur100mD = listePreferences[ 9] aerodromeD = listePreferences[10] nomPisteChoisieD = listePreferences[11] limiterVolPrincipalD = 1 limiterVolComparatifD = 1 annotationGeneVolPrincipalD = listePreferences[12] annotationInterVolPrincipalD = listePreferences[13] pasAnnotInterVolPrincipalD = listePreferences[14] # creer fenetre graphique root = Tkinter.Tk() Pmw.initialise(root) root.title('apoglide') f = ConstruireFenetreDeBase( root , dossierHome , langageD , xGrapheD , yGrapheD , echelleD , anamorphismeD , obliciteD , dessinerTrianglePisteD , ecrireNomPisteD , dessinerVecteur100mD , aerodromeD , nomPisteChoisieD , limiterVolPrincipalD , limiterVolComparatifD , annotationGeneVolPrincipalD , annotationInterVolPrincipalD , pasAnnotInterVolPrincipalD ) root.mainloop()