PVL/pvl.py

#########################################################################
#	Beschreibung:	Berechnung der Distanz Luftlinie zweier Orte 	#
#			in Deutschland in km.				#
#									#
#	Erstellt von:	Francine Theil, Kristin Weber, Willi Schlegel	#
#	Datum:		10.06.2017					#
#									#
#########################################################################

#--------------------------------------------------------------
#       benoetigte module importieren

import re                                       # modul fuer regulaere ausdruecke
import sys                                      # modul fuer systemoperationen
import math as m                                # modul fuer mathematische berechnungen
import logging                                  # modul fuer protokolierungen


#--------------------------------------------------------------
#       verwendung von logging
#       das log-file wird als log.txt im hauptverzeichnis abgelegt

deb=logging.basicConfig(filename="log.txt", level=logging.DEBUG,
format="%(asctime)s: %(levelname)s: %(message)s ")                                      #debug logging

err=logging.basicConfig(filename="log.txt", level=logging.ERROR,
format="%(asktime)s: %(levelname)s: %(message)s ")                                      #error logging

inf=logging.basicConfig(filename="log.txt", level=logging.INFO,
format="%(asktime)s: $(levelname)s: %(message)s ")                                      #info logging


#-------------------------------------------------------------
#       menue erstellen ab diesem punkt beginnt die anwendung

def menu():                                                                             #funktion als menue

	logging.info("Die Anwendung wurde ordnungsgemaess gestartet")			#wenn die anwendung gestarten werden konnte, erfolgt ein logging
	print " "
        wahl = raw_input("Berechnung beginnen? [y/n] ")					#abfrage ob die berechnug durchgefuehrt werden soll
	print " "
        if wahl == "y":									#bei der eingabe eines y wird die funktion ort1() ausgefuehrt
                ort1()

        elif wahl == "n":								#bei der eingabe eines n wird die anwendung beendet
		logging.info("Die Anwendung wurde ordnungsgemaess beendet")		#logging ausgeben
                sys.exit()
	else:										#falls eine falsche eingabe erfolgt wird ein error logging erzeugt
		logging.error("Die Anwendung konnte nicht gestartet werden")		#und die funktion menu wird erneut ausgefuehrt
		menu()


#--------------------------------------------------------------
#       funktion (menue) fuer die eingabe des ersten ortes

def ort1():                                                                             #funktion fuer die eingabe des ersten ortes

        eingabe1=raw_input("Ersten Ort eingeben: ")                                     #eingabe des ersten ortes
        datei=open("DE.tab")                                                            #datei oeffnen
        tmp = []                                                                        #datei temporaer gespeichert
        print " "
        for line in datei:                                                              #zeilenweise auslesen der datei
                if re.findall(eingabe1, line):                                          #weiter wenn die eingabe mit dem ort in der datei ubereinstimmen
                        logging.info("Der erste eingegebene Ort wurde gefunden")        #logging als info wenn ort in der datei gefunden wurde
                        a=line.split("\t")                                              #eichenketten der gelesenen zeilen aufteilen
                        print a[3]                                                      #dritte zeichenkette/spalte ausgeben
                        tmp.append(a)                                                   #auflisten der gefundenen ergebnisse
                        logging.debug(a)                                                #logging als debug vermerken
        datei.close()                                                                   #datei schliessen
        print " "
        nr = int(raw_input("Welcher Vorschlag soll verwendet werden? "))                #auswahl der vorgeschlagenen staedte
        print " "
        ort2(tmp[nr])                                                                   #weiter zur funktion -ort2- inkl. globale variablen


#---------------------------------------------------------------

def ort2(a):                                                                            #funktion fuer die eingabe des zweiten ortes                        $

        eingabe2=raw_input("Zweiten Ort eingeben: ")                                    #eingabe des zweiten ortes
        datei=open("DE.tab")                                                            #datei oeffnen
        tmp = []                                                                        #datei temporaer gespeichert
        print " "
        for line in datei:                                                              #zeilenweise auslesen aus der datei
                if re.findall(eingabe2, line):                                          #weiter wenn die eingabe mit dem ort in der datei ubereinstimmen
                        b=line.split("\t")                                              #gelesene zeilen aufteilen (rstrip) und die position 7 bis 15 ([]) m$
                        print b[3]                                                      #dritte zeichenkette/spalte ausgeben
                        tmp.append(b)                                                   #auflisten der gefundenen ergebnisse
                        logging.debug(b)                                                #logging als debug ausgeben
        datei.close()                                                                   #datei schliessen
        print " "
        nr = int(raw_input("Welcher Vorschlag soll verwendet werden? "))                #Abfrage, welcher Vorschlag verwendet werden soll
        print " "
        koordinaten(a,tmp[nr])                                                          #


#--------------------------------------------------------------
#       longitude und latidude beider orte definieren

def koordinaten(a,b):                                                                   #funktion fuer das auslesen der koordinaten des ersten ortes

        lat=a[4]                                                                        #latitude des ersten ortes aus der liste extrahieren
        long=a[5]                                                                       #longitude des ersten ortes aus der liste extrahieren
        koordinaten2(lat, long, b)                                                      #zur funktion -koordinaten2- uebergehen


def koordinaten2(x1, y1, b):                                                            #funktion fuer da auslesen der koordinaten des zweiten ortes

	logging.debug("Die Koordinaten fuer den ersten Ort konnten ermittelt werden")	#logging ausgeben
        lat = b[4]                                                                      #latitude des zweiten ortes aus der liste extrahieren
        long = b[5]                                                                     #longtude des zweiten ortes aus der liste extrahieren
        ausgabe(x1, y1, lat, long)                                                      #weiter zur funktion -ausgabe-


def ausgabe(x1, y1, x2, y2):                                                            #funktioon zur ausgabe der extrahierten koordinaten

	logging.debug("Die Koordinaten fuer den zweiten Ort konnten ermittelt werden")	#logging ausgeben
        print " "
        print "{}{}".format("Die X-Koordinate des ersten Ortes lautet: ", y1)
        print "{}{}".format("Die Y-Koordinate des ersten Ortes lautet: ", x1)
        print " "
        print "{}{}".format("Die X-Koordinaten des zweiten Ortes lautet: ", y2)
        print "{}{}".format("Die Y-Koordinaten des zweiten Ortes lautet: ", x2)
        print " "



#--------------------------------------------------------------
#       funktion zur berechnung der distanz beider eingegebenen orte


        r = 6371.0                                                                      #angabe des radius der erde
        lat1=float(x1)*2*m.pi/360                                                       #latitude des ersten ortes in bogenmass umrechnen
        lat2=float(x2)*2*m.pi/360                                                       #latitude des zweiten ortes in bogenmass umrechnen
        long1=float(y1)*2*m.pi/360                                                      #longtude des ersten ortes in bogenmass umrechnen
        long2=float(y2)*2*m.pi/360                                                      #longtude des zweiten ortes in bogenmass umrechnen
        x1 = float(r*m.cos(long1)*m.cos(lat1))                                          #x koordinaten des ersten ortes berechnen
        y1 = float(r*m.sin(long1)*m.cos(lat1))                                          #y koordinaten des ersten ortes berechnen
        z1 = float(r*m.sin(lat1))                                                       #z koordinaten des ersten ortes berechnen
        x2 = float(r*m.cos(long2)*m.cos(lat2))                                          #x koordinaten des zweiten ortes berechnen
        y2 = float(r*m.sin(long2)*m.cos(lat2))                                          #y koordinaten des zweiten ortes berechnen
        z2 = float(r*m.sin(lat2))                                                       #z koordinaten des zweiten ortes berechnen

        skalarprod = x1*x2+y1*y2+z1*z2                                                  #skalarprodukt der koordinaten bilden
        Betrag1 = m.sqrt(x1*x1+y1*y1+z1*z1)                                             #betrag des ersten ortes bilden
        Betrag2 = m.sqrt(x2*x2+y2*y2+z2*z2)                                             #betrag des zweiten ortes bilden
        tmp=m.acos(skalarprod/(Betrag1*Betrag2))                                        #arcuskosinus bilden
        ergebnis = tmp * r                                                                      #ergebnis der entfernung beider orte
        ergebnis = round(ergebnis)                                                           	#aufgerundetes ergebnis der entfernung beider orte
        print "{} {} {}".format("Die Orte sind ", ergebnis, "Km voneinander entfernt")          #ausgabe der berechnung
        print " "

	logging.debug("Die Distanz konnte berechnet werden")				#logging ausgeben

	menu()										#zurueck zum menu
#---------------------------------------------------------------
#       menue zur erneuten abfrage der berechnung

menu()											#funktion schliessen - zurueck zum menu - als "schleife"