11. Jupyter Notebook

ehemalige Veranstaltungen ia3.netz + ia3.data sowie ia4.Netz im Studiengang Interaktive Medien

(c) 2020 Hochschule Augsburg - Fakultät für Informatik - Prof.Dr.Nik Klever

In [ ]:
mittelpunkt = Ort(dict(lat=48.358867,lon=10.906,alt=0))

url = "http://maps.googleapis.com/maps/api/staticmap?size=640x640&maptype=satellite&key={}".format(GOOGLEAPIKEY) 

url += "&markers=color:green|{:.6f},{:.6f}".format(mittelpunkt.lat,mittelpunkt.lon)
url += "&markers=color:blue"

for wegdatum in alleWegDaten:
    url += "|{:.6f},{:.6f}".format(wegdatum.lat,wegdatum.lon)

Image(url=url)
In [ ]:
import math
class Ort(object):
    def __init__(self,kw):
        self.lat = kw['lat']
        self.lon = kw['lon']
        if 'alt' in kw:
            self.alt = kw['alt']
        else:
            self.alt = 0.0
    def getKoord(self):
        return dict(lon=self.lon,lat=self.lat,alt=self.alt)
    def setKoord(self,lon,lat,alt):
        self.lon = lon
        self.lat = lat
        self.alt = alt
    def abstand(self,zweiterort,typ="Kugel"):
        if typ == "Flaeche": # Berechnung des Abstands auf einer Fläche
            return math.sqrt((self.lon - zweiterort.lon)**2+(self.lat - zweiterort.lat)**2)*111
        else: # Berechnung des Abstands auf einer Kugel
            RadiusErde = 6371000 # mittlerer Radius der Erde in m
            lat1 = math.radians(self.lat)
            lat2 = math.radians(zweiterort.lat)
            lon1 = math.radians(self.lon)
            lon2 = math.radians(zweiterort.lon)
            return math.acos(math.sin(lat1) * math.sin(lat2) + \
                   math.cos(lat1) * math.cos(lat2) * math.cos(lon2-lon1)) * RadiusErde
        
f = open('wegdaten.csv','r')
gesamterInhalt = f.read()
f.close()

zeilen = gesamterInhalt.split('\n')[:-1]
spaltendefinition = zeilen[0].split(';')

alleWegDaten = []

for zeile in zeilen[1:]:
    spalten = zeile.split(';')
    wegdatum = Ort(dict((spaltendefinition[x], float(spalten[x])) for x in range(len(spalten))))
    alleWegDaten.append(wegdatum)
In [ ]:
mittelpunkt = Ort(dict(lat=48.358867,lon=10.906,alt=0))
radius = 100

url = "http://maps.googleapis.com/maps/api/staticmap?size=640x640&maptype=satellite&key={}".format(GOOGLEAPIKEY) 

url += "&markers=color:green|{:.6f},{:.6f}".format(mittelpunkt.lat,mittelpunkt.lon)
url += "&markers=color:blue"

for wegdatum in alleWegDaten:
    if  wegdatum.abstand(mittelpunkt) > radius:
        url += "|{:.6f},{:.6f}".format(wegdatum.lat,wegdatum.lon)
In [ ]:
url += "&markers=color:red"

for wegdatum in alleWegDaten:
    if wegdatum.abstand(mittelpunkt) < radius:
        url += "|{:.6f},{:.6f}".format(wegdatum.lat,wegdatum.lon)

Image(url=url)
In [ ]:
from urllib.request import urlopen
import math

class Ort(object):
    def __init__(self,kw):
        self.lat = kw['lat']
        self.lon = kw['lon']
        if 'alt' in kw:
            self.alt = kw['alt']
        else:
            self.alt = 0.0
    def getKoord(self):
        return dict(lon=self.lon,lat=self.lat,alt=self.alt)
    def setKoord(self,lon,lat,alt):
        self.lon = lon
        self.lat = lat
        self.alt = alt
    def abstand(self,zweiterort,typ="Kugel"):
        if typ == "Flaeche": # Berechnung des Abstands auf einer Fläche
            return math.sqrt((self.lon - zweiterort.lon)**2+(self.lat - zweiterort.lat)**2)*111
        else: # Berechnung des Abstands auf einer Kugel
            RadiusErde = 6371000 # mittlerer Radius der Erde in m
            lat1 = math.radians(self.lat)
            lat2 = math.radians(zweiterort.lat)
            lon1 = math.radians(self.lon)
            lon2 = math.radians(zweiterort.lon)
            return math.acos(math.sin(lat1) * math.sin(lat2) + \
                   math.cos(lat1) * math.cos(lat2) * math.cos(lon2-lon1)) * RadiusErde


class WegDaten():
    def __init__(self,filename_or_url):
        if filename_or_url.startswith("http"):
            f = urlopen(filename_or_url)
            self.gesamterInhalt = f.read()
        else:
            f = open(filename_or_url)
            self.gesamterInhalt = f.read()
            f.close()
    
    def parseCSV(self):
        zeilen = self.gesamterInhalt.split('\n')
        spaltendefinition = zeilen[0].split(';')
        
        self.alleWegDaten = []

        for zeile in zeilen[1:]:
            spalten = zeile.split(';')
            wegdatum = Ort(dict((spaltendefinition[x], float(spalten[x])) for x in range(len(spalten))))
            self.alleWegDaten.append(wegdatum)
            
    def writeGoogleStaticMapsUrl(self,lon,lat,alt,radius):
        mittelpunkt = Ort(dict(lat=lat,lon=lon,alt=alt))

        url = "http://maps.googleapis.com/maps/api/staticmap?size=640x640&maptype=satellite&key={}".format(GOOGLEAPIKEY) 

        url += "&markers=color:green|{:.6f},{:.6f}".format(mittelpunkt.lat,mittelpunkt.lon)
        url += "&markers=color:blue"

        for wegdatum in self.alleWegDaten:
            if  wegdatum.abstand(mittelpunkt) > radius:
                url += "|{:.6f},{:.6f}".format(wegdatum.lat,wegdatum.lon)
                
        url += "&markers=color:red"

        for wegdatum in self.alleWegDaten:
            if wegdatum.abstand(mittelpunkt) < radius:
                url += "|{:.6f},{:.6f}".format(wegdatum.lat,wegdatum.lon)

        return url
    
from IPython.display import Image

instanz = WegDaten("wegdaten.csv")
instanz.parseCSV()
url = instanz.writeGoogleStaticMapsUrl(48.358867,10.906,0,100)

Image(url=url)
In [2]:
%%writefile GeoLocation.py
from urllib.request import urlopen
from xml.sax import make_parser, parseString, handler, SAXException, SAXParseException
import math

GOOGLEAPIKEY = "..."

class Ort(object):
    def __init__(self,kw):
        self.lat = kw['lat']
        self.lon = kw['lon']
        if 'alt' in kw:
            self.alt = kw['alt']
        else:
            self.alt = 0.0
    def getKoord(self):
        return dict(lon=self.lon,lat=self.lat,alt=self.alt)
    def setKoord(self,lon,lat,alt):
        self.lon = lon
        self.lat = lat
        self.alt = alt
    def abstand(self,zweiterort,typ="Kugel"):
        if typ == "Flaeche": # Berechnung des Abstands auf einer Fläche
            return math.sqrt((self.lon - zweiterort.lon)**2+(self.lat - zweiterort.lat)**2)*111
        else: # Berechnung des Abstands auf einer Kugel
            RadiusErde = 6371000 # mittlerer Radius der Erde in m
            lat1 = math.radians(self.lat)
            lat2 = math.radians(zweiterort.lat)
            lon1 = math.radians(self.lon)
            lon2 = math.radians(zweiterort.lon)
            return math.acos(math.sin(lat1) * math.sin(lat2) + \
                   math.cos(lat1) * math.cos(lat2) * math.cos(lon2-lon1)) * RadiusErde

class SAXGPXParser(handler.ContentHandler, Ort):
    
    def __init__(self):
        self.alleWegDaten = []
        self.aktuellerName = ''
    
    
    def startElement(self, name, attrs):
        self.aktuellerName = name
        if name == 'trkpt':
            self.wegdatum = {}  
            for attr in attrs.getNames():
                self.wegdatum[attr] = float(attrs.getValue(attr))           
        
    def characters(self, content):
        if self.aktuellerName == 'ele':
            self.wegdatum['alt'] = float(content)
            self.alleWegDaten.append(Ort(self.wegdatum)) 
        
    def endElement(self, name):
        self.aktuellerName = ''


class WegDaten():
    def __init__(self,filename_or_url):
        if isinstance(filename_or_url, str):
            if filename_or_url.startswith("http"):
                f = urlopen(filename_or_url)
                self.gesamterInhalt = f.read()
            else:
                f = open(filename_or_url)
                self.gesamterInhalt = f.read()
                f.close()
        else:
            f = filename_or_url
            self.gesamterInhalt = f.read().decode('utf-8')
    
    def parseCSV(self):
        zeilen = self.gesamterInhalt.split('\n')
        spaltendefinition = zeilen[0].split(';')
        
        self.alleWegDaten = []

        for zeile in zeilen[1:]:
            spalten = zeile.split(';')
            wegdatum = Ort(dict((spaltendefinition[x], float(spalten[x])) for x in range(len(spalten))))
            self.alleWegDaten.append(wegdatum)

    def parseGPX(self):
        instanz = SAXGPXParser()
        parseString(self.gesamterInhalt,instanz)
        self.alleWegDaten = instanz.alleWegDaten
        
        
    def writeGoogleStaticMapsUrl(self,lon,lat,alt,radius):
        mittelpunkt = Ort(dict(lat=lat,lon=lon,alt=alt))

        url = "http://maps.googleapis.com/maps/api/staticmap?size=640x640&maptype=satellite&key={}".format(GOOGLEAPIKEY) 

        url += "&markers=color:green|{:.6f},{:.6f}".format(mittelpunkt.lat,mittelpunkt.lon)
        url += "&markers=color:blue"

        for wegdatum in self.alleWegDaten:
            if  wegdatum.abstand(mittelpunkt) > radius:
                url += "|{:.6f},{:.6f}".format(wegdatum.lat,wegdatum.lon)
                
        url += "&markers=color:red"

        for wegdatum in self.alleWegDaten:
            if wegdatum.abstand(mittelpunkt) < radius:
                url += "|{:.6f},{:.6f}".format(wegdatum.lat,wegdatum.lon)

        return url

if __name__ == "__main__":
    from IPython.display import Image

    instanz = WegDaten("wegdaten.csv")
    instanz.parseCSV()
    url = instanz.writeGoogleStaticMapsUrl(48.358867,10.906,0,100)

    Image(url=url)
Overwriting GeoLocation.py
In [5]:
%%writefile flaskServerGeoLocation.py
# -*- coding: utf-8 -*-
from flask import Flask, request, render_template_string
from GeoLocation import WegDaten

app = Flask(__name__)
app.debug = True

geolocation_template = """<!doctype HTML>
<html>
<head>
<title>GeoLocation Anwendung</title>
</head>
<body>
<h1>GeoLocation Anwendung</h1>
<form action="/upload" method="POST" enctype="multipart/form-data">
 <p>Längengrad <input type="text" name="lon"/></p>
 <p>Breitengrad <input type="text" name="lat"/></p>
 <p>Radius <input type="text" name="radius"/></p>
 <p>Wegdaten Datei (CSV oder GPX) <input type="file" name="upload"/></p>
 <p><input type="submit" value="Datei hochladen"/></p>
</form>
<p>Vielen Dank!</p>
</body>
</html>
"""

google_staticmaps_template = """<!doctype HTML>
<html>
<head>
<title>GeoLocation Anwendung</title>
</head>
<body>
<h1>Google Static Map {{ dateiname }}</h1>
<img src="{{ url }}"/>
</body>
</html>
"""

@app.route('/')
def index():
    return render_template_string(geolocation_template)

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
    if request.method == 'POST':
        f = request.files['upload']
        
        instanz = WegDaten(f)
        if f.filename.lower().endswith(".gpx"):
            instanz.parseGPX()
        elif f.filename.lower().endswith(".csv"):
            instanz.parseCSV()

        radius = float(request.form['radius'])
        lat = float(request.form['lat'])
        lon = float(request.form['lon'])
        
        url = instanz.writeGoogleStaticMapsUrl(lon,lat,0,radius)
        
        return render_template_string(google_staticmaps_template, url=url, dateiname=f.filename)

if __name__ == "__main__":
    app.run(host="0.0.0.0",port=8500)
Overwriting flaskServerGeoLocation.py
In [2]:
%%writefile GeoLocation.py
from urllib.request import urlopen
from xml.sax import make_parser, parseString, handler, SAXException, SAXParseException
import math

GOOGLEAPIKEY = "..."

class Ort(object):
    def __init__(self,kw):
        self.lat = kw['lat']
        self.lon = kw['lon']
        if 'alt' in kw:
            self.alt = kw['alt']
        else:
            self.alt = 0.0
    def getKoord(self):
        return dict(lon=self.lon,lat=self.lat,alt=self.alt)
    def setKoord(self,lon,lat,alt):
        self.lon = lon
        self.lat = lat
        self.alt = alt
    def abstand(self,zweiterort,typ="Kugel"):
        if typ == "Flaeche": # Berechnung des Abstands auf einer Fläche
            return math.sqrt((self.lon - zweiterort.lon)**2+(self.lat - zweiterort.lat)**2)*111
        else: # Berechnung des Abstands auf einer Kugel
            RadiusErde = 6371000 # mittlerer Radius der Erde in m
            lat1 = math.radians(self.lat)
            lat2 = math.radians(zweiterort.lat)
            lon1 = math.radians(self.lon)
            lon2 = math.radians(zweiterort.lon)
            return math.acos(math.sin(lat1) * math.sin(lat2) + \
                   math.cos(lat1) * math.cos(lat2) * math.cos(lon2-lon1)) * RadiusErde

class SAXGPXParser(handler.ContentHandler, Ort):
    
    def __init__(self):
        self.alleWegDaten = []
        self.aktuellerName = ''
    
    
    def startElement(self, name, attrs):
        self.aktuellerName = name
        if name == 'trkpt':
            self.wegdatum = {}  
            for attr in attrs.getNames():
                self.wegdatum[attr] = float(attrs.getValue(attr))           
        
    def characters(self, content):
        if self.aktuellerName == 'ele':
            self.wegdatum['alt'] = float(content)
            self.alleWegDaten.append(Ort(self.wegdatum)) 
        
    def endElement(self, name):
        self.aktuellerName = ''


class SAXKMLParser(handler.ContentHandler, Ort):
    
    def __init__(self):
        self.alleWegDaten = []
        self.aktuellerName = ''

    def startElement(self, name, attrs):
        self.aktuellerName = name

    def characters(self, content):
        if self.aktuellerName == 'coordinates':
            for line in content.splitlines():
                if line.strip():
                    lon, lat, alt = line.split(',')
                    self.alleWegDaten.append(Ort(dict(lat=float(lat),lon=float(lon),alt=float(alt))))
    
    def endElement(self, name):
        self.aktuellerName = ''

class WegDaten():
    def __init__(self,filename_or_url):
        if isinstance(filename_or_url, str):
            if filename_or_url.startswith("http"):
                f = urlopen(filename_or_url)
                self.gesamterInhalt = f.read()
            else:
                f = open(filename_or_url)
                self.gesamterInhalt = f.read()
                f.close()
        else:
            f = filename_or_url
            self.gesamterInhalt = f.read().decode('utf-8')
    
    def parseCSV(self):
        zeilen = self.gesamterInhalt.split('\n')
        spaltendefinition = zeilen[0].split(';')
        
        self.alleWegDaten = []

        for zeile in zeilen[1:]:
            spalten = zeile.split(';')
            wegdatum = Ort(dict((spaltendefinition[x], float(spalten[x])) for x in range(len(spalten))))
            self.alleWegDaten.append(wegdatum)

    def parseGPX(self):
        instanz = SAXGPXParser()
        parseString(self.gesamterInhalt,instanz)
        self.alleWegDaten = instanz.alleWegDaten
        
    def parseKML(self):
        instanz = SAXKMLParser()
        parseString(self.gesamterInhalt,instanz)
        self.alleWegDaten = instanz.alleWegDaten

    def writeGoogleStaticMapsUrl(self,lon,lat,alt,radius):
        mittelpunkt = Ort(dict(lat=lat,lon=lon,alt=alt))

        url = "http://maps.googleapis.com/maps/api/staticmap?size=640x640&maptype=satellite&key={}".format(GOOGLEAPIKEY) 

        url += "&markers=color:green|{:.6f},{:.6f}".format(mittelpunkt.lat,mittelpunkt.lon)
        url += "&markers=color:blue"

        for wegdatum in self.alleWegDaten:
            if  wegdatum.abstand(mittelpunkt) > radius:
                url += "|{:.6f},{:.6f}".format(wegdatum.lat,wegdatum.lon)
                
        url += "&markers=color:red"

        for wegdatum in self.alleWegDaten:
            if wegdatum.abstand(mittelpunkt) < radius:
                url += "|{:.6f},{:.6f}".format(wegdatum.lat,wegdatum.lon)

        return url

if __name__ == "__main__":
    from IPython.display import Image

    instanz = WegDaten("wegdaten.csv")
    instanz.parseCSV()
    url = instanz.writeGoogleStaticMapsUrl(48.358867,10.906,0,100)

    Image(url=url)
Overwriting GeoLocation.py