
#!/usr/bin/env python2

import mapnik
# Create a map
m = mapnik.Map(600,300) # create a map with a given width and height in pixels
# note: m.srs will default to '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
# the 'map.srs' is the target projection of the map and can be whatever you wish 
m.background = mapnik.Color('steelblue') # set background colour to 'steelblue'.  

# Create a style
s = mapnik.Style() # style object to hold rules
r = mapnik.Rule() # rule object to hold symbolizers

# to fill a polygon we create a PolygonSymbolizer
polygon_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color('#f2eff9'))
r.symbols.append(polygon_symbolizer) # add the symbolizer to the rule object

# to add outlines to a polygon we create a LineSymbolizer
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'),0.1)
r.symbols.append(line_symbolizer) # add the symbolizer to the rule object
s.rules.append(r) # now add the rule to the style and we're done

# Add the style to the map
m.append_style('My Style',s) # Styles are given names only as they are applied to the map

# Create a datasource
ds = mapnik.Shapefile(file='ne_110m_admin_0_countries.shp')

# Create a layers
layer = mapnik.Layer('world') # new layer called 'world' (we could name it anything)
# note: layer.srs will default to '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'

layer.datasource = ds # attach the datasource to the layer
layer.styles.append('My Style') # attach the style to the layer

# Prepare the map for rendering
m.layers.append(layer)
m.zoom_all()
# Render the map to the file 
mapnik.render_to_file(m,'world.png', 'png')
print "rendered image to 'world.png'"


#!/usr/bin/env python2
# render_osm_directly.py

from mapnik import *

mapfile = 'mapnik_style.xml'
map_output = 'mymap.png'

m = Map(4*1024,4*1024)
load_map(m, mapfile)
bbox=(Envelope( 10.0,47.5,11.1,48.1 ))

m.zoom_to_box(bbox)
print "Scale = " , m.scale()
render_to_file(m, map_output)


# -*- coding: utf-8 -*-
"""
@author: nik.klever@hs-augsburg.de
"""

from xml.sax import parseString, handler, SAXException, SAXParseException
import math
import io


import math
class Location(object):
    """
    class Location to define a location on the earth surface and to calculate
    the distance of two locations
    """
    
    def __init__(self,kw):
        self.lat = kw['lat']
        self.lon = kw['lon']
        self.alt = kw['alt']

    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 distance(self,sndloc,type="sphere"):
        if type == "area": # calculate the distance on a 2D area
            return math.sqrt((self.lon - sndloc.lon)**2+(self.lat - sndloc.lat)**2)*100
        else: # calculate the distance on a 3D sphere
            RadiusEarth = 6371000 # medium radius of the earth in m
            lat1 = math.radians(self.lat)
            lat2 = math.radians(sndloc.lat)
            lon1 = math.radians(self.lon)
            lon2 = math.radians(sndloc.lon)
            return math.acos(math.sin(lat1) * math.sin(lat2) + \
                   math.cos(lat1) * math.cos(lat2) * math.cos(lon2-lon1)) * RadiusEarth


class GPXParser(handler.ContentHandler,Location):
    """
    Reading and parsing of GPX XML data via this SAX Content-Handler class
    """
    
    def __init__(self):
        self.waypoints = []
        self.ele = None
    
    def startElement(self, name, attr):
        if name == "trkpt":
            lat = float(attr.getValue("lat"))
            lon = float(attr.getValue("lon"))
            self.waypoints.append(Location(dict(lat=lat,lon=lon,alt=0)))
        elif name == "ele":
            self.ele = len(self.waypoints)
    
    def characters(self, ch):
        if self.ele:
            self.waypoints[self.ele-1].alt = float(ch)
    
    def endElement(self, name):
        if name == "ele":
            self.ele = None

class KMLParser(handler.ContentHandler,Location):
    """
    Reading and parsing of KML XML data via this SAX Content-Handler class
    """
    
    def __init__(self):
        self.waypoints = []
        self.coordinates = False
    
    def startElement(self, name, attr):
        if name == "coordinates":
            self.coordinates = True
    
    def characters(self, ch):
        if self.coordinates:
            for line in ch.splitlines():
                if line.strip():
                    lon, lat, alt = line.split(',')
                    self.waypoints.append(Location(dict(lat=float(lat),lon=float(lon),alt=float(alt))))
    
    def endElement(self, name):
        if name == "coordinates":
            self.coordinates = False

            
class WayPoints(Location):
    """
    class WayPoints to read the waypoints (either as stream, as list or as a file), 
    to parse them (either as CSV, GPX or KML) and create a Google Static Map or a Google Map Object
    """
    
    def __init__(self,filename_or_stream_or_allLines):
        # Test for the type of the parameter filename_or_stream_or_allLines 
        if isinstance(filename_or_stream_or_allLines, io.BytesIO):
            self.lines = filename_or_stream_or_allLines.read().split('\n')[:-1]
        elif isinstance(filename_or_stream_or_allLines, list):
            self.lines = filename_or_stream_or_allLines
        elif isinstance(filename_or_stream_or_allLines, str):
            f = open(filename_or_stream_or_allLines,'r')
            self.lines = f.read().split('\n')[:-1]
            f.close()
        else:
            raise IOError("wrong type for data input")
    
    def parseCSV(self):
        self.waypoints = []
        columndefinition = self.lines[0].split(';')
        for line in self.lines[1:]:
            columns = line.split(';')
            waypoint = Location(dict((columndefinition[x], float(columns[x])) for x in range(len(columns))))
            self.waypoints.append(waypoint)

    def parseGPX(self):
        gpxhandler = GPXParser()
        parseString('\n'.join(self.lines),gpxhandler)
        self.waypoints = gpxhandler.waypoints        
        
    def parseKML(self):
        kmlhandler = KMLParser()
        parseString('\n'.join(self.lines),kmlhandler)
        self.waypoints = kmlhandler.waypoints

    def writeGoogleStaticMapsUrl(self,radius,lat,lon,alt=0,size='640x640'):
        center = Location(dict(lat=lat,lon=lon,alt=alt))
        radius = radius
        url = "http://maps.google.com/maps/api/staticmap?size={}&maptype=satellite&sensor=false".format(size)
        url += "&markers=color:green|{:.6f},{:.6f}".format(center.lat,center.lon)
        url += "&markers=color:blue"
        for waypoint in self.waypoints:
            if waypoint.distance(center) > radius:
                url += "|{:.6f},{:.6f}".format(waypoint.lat,waypoint.lon)
        url += "&markers=color:red"
        for waypoint in self.waypoints:
            if waypoint.distance(center) < radius:
                url += "|{:.6f},{:.6f}".format(waypoint.lat,waypoint.lon)
        return url

    def createGoogleMapsObject(self,radius,lat,lon,alt=0):
        from flask.ext.googlemaps import Map
        center = Location(dict(lat=lat,lon=lon,alt=alt))
        markers = { 'http://maps.google.com/mapfiles/ms/icons/green-dot.png':[(center.lat,center.lon)],
                    'http://maps.google.com/mapfiles/ms/icons/red-dot.png':[(waypoint.lat,waypoint.lon) for waypoint in self.waypoints if waypoint.distance(center) < radius],
                    'http://maps.google.com/mapfiles/ms/icons/blue-dot.png':[(waypoint.lat,waypoint.lon) for waypoint in self.waypoints if waypoint.distance(center) > radius]}
        googlemap = Map(identifier="view-side",style="width:560px;height:560px;margin:0;",zoom=15,maptype="SATELLITE",lat=lat,lng=lon,markers=markers)
        return googlemap

    def createOSMObject(self,radius,lat,lon,alt=0):
        center = Location(dict(lat=lat,lon=lon,alt=alt))
        return dict(radius=radius,center=center,waypoints=self.waypoints)

if __name__ == "__main__":
    """
    Only for testing purposes
    """
    import sys
    filename= sys.argv[1]
    instance = WayPoints(filename)
    firstLine = instance.lines[0]
    if firstLine.startswith('<?xml'):
        if '<gpx' in firstLine.lower() or (len(instance.lines) > 1 and '<gpx' in instance.lines[1].lower()):
            instance.parseGPX()
        elif '<kml' in firstLine.lower() or (len(instance.lines) > 1 and '<kml' in instance.lines[1].lower()):
            instance.parseKML()
        else:
            raise "Wrong XML Format for Data Input - currently only GPX or KML allowed"
    elif 'lon' in firstLine and 'lat' in firstLine:
        instance.parseCSV()
    else:
        raise "Wrong Format for Data Input - currently only GPX, KML or CSV allowed"

    mlon = float(sys.argv[2])
    mlat = float(sys.argv[3])
    radius = float(sys.argv[4])
    
    if sys.argv[5] == 'googlestaticmap':
        url=instance.writeGoogleStaticMapsUrl(radius,mlat,mlon,size='560x560')
        print url
    elif sys.argv[5] == 'googlemap':
        googlemap=instance.createGoogleMapsObject(radius,mlat,mlon)
        print googlemap
    elif sys.argv[5] == 'osm':
        osm=instance.createOSMObject(radius,mlat,mlon)
        print osm


# -*- coding: utf-8 -*-
"""
@author: nik.klever@hs-augsburg.de
"""

from flask import Flask, render_template, request
import os
import logging
from GeoLocation import WayPoints, GPXParser, KMLParser
from flask.ext.googlemaps import GoogleMaps

# Flask Application GeoLocation
app = Flask("GeoLocationWebserver")
GoogleMaps(app)
app.debug = True
if not app.debug:
    from logging import StreamHandler
    err_handler = StreamHandler()
    app.logger.addHandler(err_handler)

app.logger.setLevel(logging.INFO)

# Rootpage
@app.route('/')
def root():
    return render_template("index.html")

# Call of the application with /geolocation 
@app.route('/geolocation', methods=['GET', 'POST'])
def geolocation():
    if not request.form:
        return render_template("geolocation.html", form=True)

    filestream = request.files['geodatei'].stream

    try:
        app.instance = WayPoints(filestream)
    except IOError:
        return render_template("error.html", message="Wrong Type for Data Input")
    firstLine = app.instance.lines[0]
    if firstLine.startswith('<?xml'):
        if '<gpx' in firstLine.lower() or (len(app.instance.lines) > 1 and '<gpx' in app.instance.lines[1].lower()):
            app.instance.parseGPX()
        elif '<kml' in firstLine.lower() or (len(app.instance.lines) > 1 and '<kml' in app.instance.lines[1].lower()):
            app.instance.parseKML()
        else:
            return render_template("error.html", message="Wrong XML Format for Data Input - currently only GPX or KML allowed")
    elif 'lon' in firstLine and 'lat' in firstLine:
        app.instance.parseCSV()
    else:
        return render_template("error.html", message="Wrong Format for Data Input - currently only GPX or CSV allowed")

    mlon = float(request.form['mlon'])
    mlat = float(request.form['mlat'])
    radius = float(request.form['radius'])

    url = None
    googlemap = None
    osm = None
        
    if request.form['output'] == 'googlestaticmap':
        url=app.instance.writeGoogleStaticMapsUrl(radius,mlat,mlon,size='560x560')
    elif request.form['output'] == 'googlemap':
        googlemap=app.instance.createGoogleMapsObject(radius,mlat,mlon)
    elif request.form['output'] == 'openstreetmap':
        osm=app.instance.createOSMObject(radius,mlat,mlon)
    else:
        return render_template("error.html", message="Wrong Format for Data Output")
    return render_template("geolocation.html", url=url, googlemap=googlemap, osm=osm)

if __name__ == '__main__':
    app.run()

OpenStreetMaps¶

Information : Transparency : Democracy¶

OpenStreetMaps¶

Contents¶

Introduction¶

Information : Transparency : Democracy and OpenStreetMaps¶

Geographic Maps¶

Map Producer - National Mapping Agencies¶

Coordinate Systems¶

Spherical Coordinate System¶

Mercator Projection (nach Lorke)¶

1. Step¶

Dividing the 3D-sphere like an orange peel into a 2D-plane¶

2. Step¶

Stretching in east-west to fill the gap between the trim lines¶

3. Step¶

but the shapes of the circles in east-west differ from north-south¶

4. Step¶

Mercator's idea: stretching also in north-south¶

Result¶

Web Maps¶

WMS Requests¶

Level 1¶

Level 2¶

Level 3¶

Positioning¶

Process of Positioning¶

Pros:¶

Cons:¶

Satellite Data Formats¶

NMEA - National Marine Electronics Association¶

Google Maps API Basic Example with Google Maps¶

Google Maps API Basic Example with OpenStreetMap¶

Task¶

JavaScript Map Libraries¶

Add Polygon and Popup on Click¶

OpenLayers Marker Example¶

Map Services¶

Tile Map Server¶

Other Examples¶

mapnik_style.xml¶

WMS Requests¶

Appendix: Geolocation WebServer¶

Flask Webserver for Importing and Viewing CSV, GPX and KML Waypoints¶

GeoLocation.py¶

FlaskServerGeoLocation.py¶

Map Producer - National Mapping Agencies ¶