################################################################################ ############# Seminar: Grafiken in R ############# ############# Visualisierung Geographischer Daten ############# ############# Hausarbeit begleitend zum Vortrag vom 20.01.2011 ############# ############# Thomas Schlesinger ############# ################################################################################ ################################################################################ ## 1) Einleitung ##### ################################################################################ # Der Inhalt dieser Hausarbeit wird sich in mehrere Teile gliedern und die # wichtigsten Funktionen der benutzten Pakete anhand von Grafiken erläutern. Als # Erstes wird ein Grid mit Hilfe von sp-Klassen erstellt, welche den Höhenunter- # schied zwischen Geoid und Ellipsoid darstellen soll. Im zweiten Teil wird mit # Hilfe des packages geonames ein Datensatz erstellt, der anschließend # mit dem package rworldmaps visualisiert wird. Die letzte Grafik wird mit dem # package RgoogleMaps erstellt und stellt die WM 2010 aus der Sicht der # deutschen Nationalmannschaft dar. # Begleitend zu dieser Hausarbeit ist es zu empfehlen sich die Präsentations- # folien aufgrund der Grafiken anzuschauen. ################################################################################ ## 2) Vorbereitungen ##### ################################################################################ # Ich empfehle mit setwd() ein working directory zu definieren, da vor allem bei # RgoogleMaps Grafiken auf dem PC gespeichert werden und sie so einfacher zu # finden sind. Die WWGRID.TXT- Datei wird in Abschnitt 3 benötigt und sollte im # working directory abgespeichert sein um das Einlesen zu vereinfachen. # Sonst sind hier Befehle zur Installation und dem Laden aller benutzter Pakete. install.packages(c("sp","maps","RColorBrewer","rworldmap","mapdata","geonames", "RgoogleMaps")) library(sp) library(rworldmap) library(geonames) library(RgoogleMaps) library(maps) library(RColorBrewer) library(mapdata) ################################################################################ ## 3)Erstellen des Worldgrids ##### ################################################################################ # Dieser Teil beschäftigt sich mit dem Erstellen der Grafik auf Folie 9. Darge- # stellt ist hier der Höhenunterschied (in Meter) zwischen Geoid und Ellipsoid. # Als Erstes gibt es aber noch eine kleine Einführung in die Spatial-Klassen. # Diese sind im sp-package implementiert und stellen eine Grundlage zum Arbeiten # mit räumlichen Daten dar. Prinzipiell besteht ein SpatialObjekt mindestens aus # einer sogenannten bbox (bounding box) und einem CRS (Coordinate Reference # System). Die bbox gibt einem anhand von 4 Koordinaten an, in welchem Bereich # sich die Daten befinden und das CRS ist nur zu Informationszwecken da. Es ent- # hält einen String indem Informationen bzgl. Ellipsoid, Projektion und Datum # stehen. Da er aber nicht zur Berechnung der Koordinaten verwendet wird, darf # er auch einen leeren String-Vektor (as.character(NA)) enthalten. # Es gibt verschiedene Arten von SpatialObjekten, die in der Präsentation weiter # ausgeführt sind. Die für die Hausarbeit relevanten, werden im Laufe derer noch # geklärt. rohdaten<- read.table(gzfile("WWGRID.TXT.gz"), header = FALSE, col.names = c("lat","long","height")) # Einlesen des Datensatzes. summary(rohdaten) # Zu der height ist zu Sagen, dass hier die Höhe des Ellipsoids von der Höhe # des Geoids subtrahiert wurde. Also negative Zahlen geben an, dass der Geoid # an der Stelle tiefer als der Ellipsoid ist. # Noch zu erwähnen ist, dass die long Variable eine range von [0,360] besitzt. # Dies wird in den folgenden Schritten auf [-180,180] umgerechnet, wobei die # 0 bleibt wo sie ist und nur [181,360] in [-180,0] umgerechnet wird. ueber180 <-subset(rohdaten, rohdaten$long>180) kleiner180 <-subset(rohdaten, rohdaten$long<=180) ueber180$long<-ueber180$long-360 # Werte von (180,360] haben nun die Werte(-180,0] rohdaten <- rbind(kleiner180, ueber180) spdat<-rohdaten # aus Sicherheitszwecken abgespeichert. coordinates(spdat)<-c("long","lat") str(spdat,max.level=2) # Nun wurde aus dem normalen Data.Frame ein SpatialPointsDataFrame gemacht. # Die Funktion coordinates ist eine Zuweisung, die angibt, welche Variablen # die longitude und latitude Variablen darstellen. Die werden dann im String # der coords gespeichert. Eine bbox wurde auch erstellt und das CRS ist ein # leerer String, da ich nichts eingefügt habe. Die Daten befinden sich in # Form einer Variable im data slot. Das Ausführen der Funktion plot(spdat) # führt nur einem schwarzen Bild und image(spdat) geht gar nicht. spdat@bbox pixdat<-as(spdat,"SpatialPixelsDataFrame") str(pixdat, max.level=2) # Es wurde nun aus dem SpatialPointsDataFrame ein SpatialPixelsDataFrame ge- # macht. Das neue Objekt macht aus den einzelnen Punkten ein Gitter, wo jeder # Punkt der Mittelpunkt einer Zelle ist. pixdat@grid # Das grid besteht nun aus 720 Zellen auf der x-Achse und 361 Zellen in der # y-Achse. Jede Zelle hat eine Größe von 0.5°x0.5°. Die Zellanzahl kann man # sich auch einfach klar machen, indem man sich die spdat@bbox anschaut. # (179.5+180)*2=719 und (90+90)*2=360. Da es aber noch eine Zelle bei 0,0 # gibt wird jeweils noch eine Zelle addiert. pixdat@bbox # Hier sieht man nochmal, dass die vorigen Punkte jetzt Mittelpunkte pro Zel- # le sind und jeweils 0.25 pro Seite hinzuaddiert wurde, damit das Grid voll- # ständig dargestellt werden kann. # Die Daten sind nachwievor unter einer Variable gespeichert. Um sie mit der # image-Funktion zeichnen zu können muss die height-Variable in einer speziellen # Art und Weise, nämlich einer Matrix von 720x361 dargestellt werden. Wo jede # Einheit in der Matrix, einer Zelle im image entspricht. Die image Funktion # bringt ein SpatialPixelsDataFrame allerdings automatisch in die richtige Form. image(pixdat) # Standardmäßig werden hier die heat.colors verwendet und die height-Variable # wird äquidistant kategorisiert. Dies wird nun verändert # Nun werden 12 colors erstellt, wie in der zu erstellenden Grafik. Diese wur- # den mit dem Paket RColorBrewer erstellt. Unter name gibt man die Farbpalette # an und n sind die Anzahl der Farben. von den sieben Farben werden nur die ers- # ten 6 benutzt. Im folgenden Plot sind die Farben zu sehen und werden annschließ- # end in der Variable heightcolors gespeichert. op<-par(mfrow=c(2,1),mar=rep(2,4)) display.brewer.pal(name="Blues",n=7) text(x=1:6, y=1, 1:6, col="red", lwd=2) title("Blues") display.brewer.pal(name="Greens",n=7) text(x=1:6, y=1, 1:6, col="red", lwd=2) title("Greens") heightcolors<-c(brewer.pal(7,"Blues")[6:1], brewer.pal(7,"Greens")[1:6]) # Der Ellipsoid passt sich an den Geoiden soweit an, dass 50% unter und 50% über # ihm liegen. Deshalb bietet es sich an die Kategorisierung mit Quantilen vor- # zunehmen, in denen bei der 0 Kategorie die hellsten Farben sind. quantbreaks<- quantile(pixdat@data[[1]], # es werden auf die Daten zugegriffen seq(0,1, length.out=length(heightcolors)+1)) # Eine Sequenz wird gebildet die von 0 bis 1 geht und die Länge des color- # Vektors+1 hat. Dies ist erforderlich da wir 12 Farben haben und somit 13 # Zahlen zur Eingrenzung. 8.3%-Quantile sind das Ergebnis. par(op) par(mar=c(2,0,2,0)) image(pixdat, col=heightcolors, breaks=quantbreaks) # mit col und breaks werden die vorher definierten Farben und Grenzen ange- # geben. Jede Farbe wird nun zu 8.3% auf der Karte vertreten. # Mit addMapLegend aus dem rworldmaps-package wird nun eine passende Legende ge- # zeichnet. addMapLegend(colourVector=heightcolors, cutVector=quantbreaks, # in colourVector und cutVector werden die vorher definierten Variablen für # die Farbe und die breaks eingesetzt. legendLabels="all", labelFontSize=0.8) # legendLabels gibt mir alle labels. Weitere Optionen: "none" & "limits" title("Geoid-Ellipsoid-Differenz") map("worldHires",add=TRUE, lwd=1.5, col="black", interior=FALSE) # Nun wird mit der map-Funktion (maps-package) und dem worldHires-Datensatz # (mapdata-package) eine Karte über das Grid gelegt. Mit interior=FALSE legt # man fest, dass nur die Grenzen zum Wasser eingezeichnet werden und keine # Interkontinentalen Staatsgrenzen. Zu weiteren Funktionen der map-function # findet man mehr in der Hausarabeit von Giuseppe Casalicchio. # Anzumerken ist, dass unterhalb der Antarktis 5° fehlen und der Rand von # Russland auf die weiße Fläche im Bild geht. Das liegt allerdings nicht an # der falschen Verbindung der map und des grids, sondern an der worldHires- # map. Diese fängt erst bei -85° an und zeichnet OstRussland über die 180° # hinaus, anstatt wieder bei -180° anzufangen. Der Urheber der worldHires- # map, die CIA, war nicht erreichbar. Deswegen wäre jegliche Begründung rei- # ne Spekulation. ################################################################################ ## 3)Geonames ##### ################################################################################ # Mit dem geonames-package ist es möglich durch verschiedene Suchanfragen auf die # Geonamesdatenbank zuzugreifen und Daten herunterzuladen. Diese werden in einem # data.frame gespeichert. # Die GNcountryInfo Funktion lädt Daten zu bestimmten Ländern herunter. Hierfür # wird ein 2-charactercode (z.B. "DE" für Deutschland) als parameter benötigt. # Wenn man allerdings die Klammer leer lässt bekommt man Daten aller 247 Länder. GNcountryInfo()->welt # Falls ein Error ausgegeben wird wegen Überlastung des Servers, kann auch # die "12-geo-II.RData"-Datei geöffnet werden. Diese hat den Datensatz welt # schon eingelesen. packages müssten allerdings nochmal geladen werden. names(welt) # Die Daten lassen sich grob in drei Gruppen einteilen. # 1. Bounding box aller Länder # 2. Unterschiedliche Länderocdes zum identifizieren. # 3. Daten, wie Währung, Kontinent,Population, Sprachen und Fläche #Da die Zahlen im characterformat sind sollten diese numerisch kodiert werden. welt$areaInSqKm<-as.numeric(welt$areaInSqKm) welt$population<-as.numeric(welt$population) # In der zu erstellenden Grafik (Teil 3) soll es um die Anzahl der Sprachen pro # Land gehen. Beispielhaft ist hier die languages Spalte des Landes Belgien an- # gezeigt. welt[20,9] # Um die nlang (number of languages) herauszufinden, wird der String an den # Kommata getrennt und gezählt wieviele Einzelstring in dem gesplitteten Vektor # sind. Die neue Anzahl der Sprachen wird in der Variable nlang gespeichtert. for(i in 1:nrow(welt)) welt$nlang[i]<-length(strsplit(welt$languages[i],split=",")[[1]]) summary(welt$nlang) ################################################################################ ## 3)rworldmaps ##### ################################################################################ # Die Grafik die nun erstellt wird befindet sich auf Folie 29 in der Präsentation. # Es wird nun der im vorigen Teil erstellte Data.Frame (welt) benutzt. plotten # kann man ihn allerdings so noch nicht. Hierfür muss man ihn in ein Spatial- # PolygonsDataFrame umwandeln. Dies ist auch ein Objekt aus dem package sp und # beinhaltet Polygone verschiedener Formen. In unserem Fall Polygone mit der Form # der Länder der Welt. Das Paket rworldmaps stellt schon ein fertiges Spatial- # PolygonsDataFrame zur Verfügung. Die Verknüpfung derer mit "welt" übernimmt # diese Funktion: geoworld<- joinCountryData2Map(dF=welt, # Im ersten Paramter wird das data.frame übergeben, was wir mit dem Objekt # verknüpfen wollen. joinCode="ISO3", nameJoinColumn="isoAlpha3") # Bei joinCode wird der Code verwendet, den wir zur Identifizierung der je- # weiligen Länder verwenden und nameJoinColumn gibt an, wo im dF sich dieser # Code befindet. Gespeichert wird das ganze in der Variable geoworld. # Die drei Zeilen in der Ausgabe geben an, wieviele Countries erkannt wurden. In # dem Fall sind es 244. Die 3 bzw 2 nicht gematchten sind wohl irrelevant. Darauf # wird aber gleich noch eingegangen. Eine Funktion zur Identifizierung der 3 gibt # es (noch) nicht. str(geoworld, max.level=2) # Die Struktur verräht nochmal, dass geworld nun ein SpatialPolygonsDataFrame # ist. Die Daten befinden sich nun im data-slot. Mit geoworld@proj4string # kann man sich nun ein Beispiel zum CRS ansehen. Es wurde für das Spatial # Objekt von einem longlat projection und einem WGS84 Ellipsoiden ausgegangen. op<-par(mar = c(0,0,2,0)) mapCountryData(mapToPlot=geoworld, nameColumnToPlot="nlang", # mapToPlot erwartet ein SpatialPolygonsDataFrame. In diesem sollte sich auch # die bei nameColumnToPlot angegebene Variable befinden. Diese wird nämlich # kategorisiert und geplottet. catMethod="categorical", # catMethod gibt an in welcher Weise die Variable kategorisiert wird. Ich # habe mich für categorical entschieden. Dies besagt, dass wir pro verwen- # deter Farbe eine Anzahl an Sprachen haben. Es wird als nichts gruppiert oceanCol="lightblue", colourPalette="topo", missingCountryCol="black", # Zwei Farben werden vergeben. lightblue an die Farbe des Wassers und die # colourPalette topo an die Farben. black wird an alle countries vergeben # die mit joinCountryData2Map nicht gematchted werden konnten. Wenn man # die map nun anschaut, bemerkt man, dass kein Land schwarz ist bzw, man er- # kennt es nicht, weil es wohl nur sehr kleine Inseln sind. mapTitle="Anzahl der Sprachen pro Land", addLegend=FALSE)->langmap # zu guter letzt wird das zeichnen der Legende unterdrückt und ein Titel für # die Grafik vergeben. Das ganze wird in in der Variable langmap gespeichert. str(langmap, max.level=2) # Neben dem Zeichnen eines Plots werden im Objekt verschiedene Werte in einer # Liste gespeichert. Die wichtigsten sind colourVector und cutVector. Sie # geben die Namen der verschiedenen Kategorien und jeweiligen Farben an. # Die gespeicherten Daten werden mit dem do.call Befehl ausgenutzt. do.call(addMapLegendBoxes, # mit do.call kann man Funktionen aufrufen und in einer Liste die Parameter # übergeben. Hier wird die Funktion addMapLegendBoxes verwendet c(langmap, # Wenn man in einem Vektor als erstes Element eine Liste einfügt, dann wer- # den alle weiteren Elemente des Vektors auch in Form einer Liste gebracht. # Diese Funktion wird hier ausgenutzt indem langmap übergeben wird. Da # colourVector und cutVector Elemente der Liste sind und addMapLegendBoxes # exakt diese beiden Parameter benötigt werden sie anerkannt und der Funktion # übergeben. horiz=TRUE, title="Anzahl der Sprachen",x="bottom", pt.cex=3, cex=1)) # Die weiteren Parameter stammen aus der legend-Funktion in Base-R und spe- # zifizieren die Legende. # Die fertige Grafik zeigt nun wieviel Sprachen es pro Land gibt mit entsprechen- # der Einfärbung. # Diese Grafik führt nochmal eine kleine Funktion vor, die auch möglich ist. Es # geht um die population der einzelnen Länder auf der Welt par(op) par(mar = c(0,0,0,0)) worldbubb<-mapBubbles(geoworld, # Die verwendete Funktion nennt sich mapBubbles und erstellt Kreise, die die # Größe einer metrischen Variable annehmen. Übergeben wird wieder ein # SpatialPolygonsDataFrame. nameZSize="population", nameZColour="continent", # nameZSize gibt an welche Variable aus dem data-slot des Objektes die Größe # des Kreises definieren soll. nameZColour dagegen die Farbe des Kreises. # Hier entschied ich mich für die population eingefärbt nach dem jeweiligen # Kontinent. Beides Informationen, die aus noch aus dem geonames data.frame # stammen. oceanCol="lightblue", landCol="wheat", colourPalette="rainbow", # Dies sind Farben für die Gewässer, das Land und eine colourPalette für die # Einfärbung der Kreise. addColourLegend=FALSE, # Auf eine Legende der Farben wird vorerst verzichtet und später hinzugfügt. legendHoriz=TRUE, legendVals=c(80*10^6, 500*10^6, 2*10^9), legendTitle="Bevölkerung") # Die Legende für die Größe der Kreise wird schon gemacht. Bei legendVals # sind die jeweils die Werte 80Mio, 0.5Mrd und 2Mrd. do.call(addMapLegendBoxes, # Es wird wieder die do.call Methode verwendet um eine Legende einzuzeichnen. c(worldbubb, horiz=TRUE, title="Kontinente", pt.cex=3, cex=1)) # Die worldbubb enthält wieder colourVector und cutVector. Deshalb werden # hier problemlos die einzelnen Parameter übergeben. # Das Ergebnis zeigt eine andere Art der Darstellung. Nämlich nicht die Einfär- # bung des kompletten Landes, sondern die Darstellung mit Kreisen. ################################################################################ ## 3)RgoogleMaps ##### ################################################################################ # Das package RgoogleMaps besitzt 2 Hauptfunktionen: Das Runterladen von static # GoogleMaps (GetMap) und das plotten auf dieser (PlotOnStaticMap) # Auf statische GoogleMaps kann man mit einer selbst erstellten, aber speziell # definierten URL zugreifen. Die GetMap-Funktion macht genau dies. Durch # verschiedene Parameter, die man ihr übergibt, bastelt sie eine URL und lädt # mit Hilfe dieser die Map auf den Computer oder zum plotten herunter. # Beispielhaft kommt nun eine Deutschlandkarte mit einer Markierung bei # Frankfurt. Diese wird allerdings nur auf dem PC gespeichert und nicht im Plot- # Window geöffnet. ger<-GetMap(center=c(51.165, 10.455278), # Im Parameter "center" wird ein Vektor von 2 Koordinaten übergeben, die # den Mittelpunkt der Karte darstellen. # c(latitude, longitude) zoom=6, # Der zoom bestimmt das Zoomlevel der Karte. Es können ganzzahlige Werte von # 0 bis 19 eingegeben werden. Und es gilt je höher die Zahl desto mehr wird # reingezoomt. destfile="deutschland.png", # Hier wird angegeben, wie die zu herunterladende Map gespeichert wird und # wie der Dateiname sein soll. maptype="terrain", # Mit maptype ist die Art der Karte gemeint. Insgesamt gibt es vier Typen # Aufgelistet mit Bildbeispiel sind sie in der Präsentation in Folie 35. marker="&markers=label:F|color:green|size:mid|50.111806,8.685944") # Der Parameter "marker" erfordert einen character-String der in eine be- # stimmten Form sein muss. Mindestanforderungen sind ein Anfang mit &markers= # und eine vollständige Koordinate. Man hat allerdings noch die Möglichkeit # Einstellungen zum Aussehen vorzunhmen (label, color, size). Diese trennt # man dann mit | . Weiter Marker können angefügt werden, wenn man den String # mit &markers= weiterführt. # Standardmäßig wird eine 640x640 pixel große Map ausgegeben. Dies kann man per # Parameter size noch ändern. 640x640 stellt aber die maximalgröße dar. # Nun wird eine Map erstellt, die sämtliche Stadien der WM 2010 in Südafrika # als marker darstellt und verschiedene Daten mithilfe von text, points und # lines daraufzeichnen. Dafür habe ich mir zwei data.frames erstellt. Stadien<-data.frame(lat=c(-26.23481,-26.19742,-33.90364,-33.93776,-29.82878, -29.11721,-25.75317,-23.92486,-25.46165,-25.57860), lon=c(27.98248, 28.06073, 18.41109, 25.59959, 31.03032, 26.20879, 28.22290, 29.46875, 30.92983, 27.16071)) DeutscheStadien<-data.frame(Tore=c(4,3,1,4,4), Gegentore=c(1,3,0,1,0), Kapa=c(62760,42486,84490,40911,64100), lat=c(-29.82878,-33.93776,-26.23481,-29.11721,-33.90364), lon=c( 31.03032, 25.59959, 27.98248, 26.20879, 18.41109), AnzahlSpiele=c(2,2,1,1,1)) # Als erstes wird ein Marker-String der Stadien erstellt: mark<-character() for(i in 1:length(Stadien$lat)) mark[i]<-paste(Stadien$lat[i],Stadien$lon[i],sep=",") # der characterVektor wird nun nach oben genannten Regeln zusammengefügt und # die Größe small gegeben. Anschließend wird noch ein zusätzlicher blauer,mid # Marker eingefügt, der das Deutsche Quartier darstellen soll. mark2<-paste(mark,collapse="&markers=size:small|") mark2<-c("&markers=size:small|",mark2,"&markers=color:blue|size:mid|-25.809581,28.094416") mark2<-paste(mark2,collapse="") # Heraus kommt ein markerString mit einer Länge von 427 Zeichen # Wie man sich sicher vorstellen kann, kommt es manchmal zu dem Problem, dass # man etwas rumspielen muss bevor man das richtige zoomlevel und den richtigen # center für seine map gefunden hat. Hierfür gibt es eine Funktion bb <- qbbox(lat=Stadien$lat, lon=Stadien$lon) # die qbbox-Funktion erwartet 2 Vektoren mit den zu enthaltenden Koordinaten. # Anschließend gibt sie einem die bounding box der zu benötigten map aus. StadienMarker<- GetMap.bbox(lonR=bb$lonR, latR=bb$latR, # Die GetMap.bbox-Funktion ist eine Erweiterung zur GetMap-Funktion. Man # übergibt ihr die Range der latitude und longitute Variablen(bevorzugt von # qbbox). Anschließend berrechnet sie daraus den Mittelpunkt und das zoom- # level was benötigt wird um die ganze bounding box abzubilden. Diese beiden # Werte werden anschließend an die standard GetMap Funktion übergeben und # alles funktioniert wie gehabt. destfile="AfricaStadienterrain.png", markers=mark2, maptype="terrain") # Die Map haben wir nun auch in einer Variable gespeichert. # Zum plotten auf der Map benötigen wir die PlotOnStaticMap Funktion: PlotOnStaticMap(StadienMarker, mar=c(0.5,0.5,1.5,0.5)) # Diese erwartet als Erstes ein "GoogleMap"-Objekt. In unserem Fall Stadien- # marker. Der mar Parameter hat hier dieselbe Funktion wie in in par. #Nun erscheint unsere Map im PlotWindow und es kann darauf geplottet werden. PlotOnStaticMap(StadienMarker, add=TRUE, # Das "GoogleMaps"-Objekt wird übergen und es wird angezeit, dass wir auf # den bestehenden plot plotten wollen. FUN=lines, # Nun wird angegeben, welche Funktion zum plotten vewendet wird. Im ersten # Fall die lines-funktion aus R-Base lat=c(-25.809581,-29.82878),lon=c(28.094416,31.03032), # Unter den Parametern lat und lon werden Werte erwartet, wie sie von der # Funktion, die wir unter FUN angegeben haben, erwartet werden. In diesem # Fall sind es die Koordinaten vom deutschen Quartier und dem Stadion in # Durban. Die Funktion macht nun folgendes: Sie rechnet die lat/lon koords # in Koordinaten des Plottes um (axis(1) und axis(2) je von -320 bis 320)und # übergibt sie der lines funktion um zu zeichnen. col="brown", lwd=2, lty=5,) # Anschließend fügt man noch Parameter der jeweilige Funktion unter FUN # hinzu. In diesem Fall braune Farbe und Linebreite und -Typ sind 2 bzw 5. # Was nun passiert ist: Eine Line wurde vom blauen Marker nach Durban gezeichnet. # Dies wird nun mit allen Deutschen Stadien gemacht. Hierfür habe ich eine for- # Schleife verwendet. color<-c(rep("brown",2),rep("black",3)) # Der Vektor welcher die Farben der Lines enthält. braun für 2 spiele und # schwarz für 1 Spiel. for(i in 1:5) PlotOnStaticMap(StadienMarker, add=TRUE, FUN=lines, lat=c(-25.809581,DeutscheStadien$lat[i]), lon=c(28.094416,DeutscheStadien$lon[i]), # Es wird nun vom gleichen Anfangspunkt (Deutsches Quartier) ausgehend, eine # Line pro Stadion gezeichnet, wo die deutsche Mannschaft gespielt hat. col=color[i],lwd=2, lty=5) # Der vorher erstellte Colorvektor wird nun benutzt um die Farben anzugeben. # Ergebnis: Man sieht Linien bei den Stadien, wo Deutschland gespielt hat. # Anmerkung: Es gibt auch einen path Parameter bei GetMap, der es ermöglicht wie # bei Google Maps Linien auf Straßen zu legen und so quasi die zu befahrenden # Straßen zu sehen. Leider war der Parameter noch fehlerhaft implementiert. # Nun wird eine Legende eingezeichnet. PlotOnStaticMap(StadienMarker, FUN=legend, add=TRUE, # bei FUN wird nun auf die legend Funktion von BaseR zugegriffen. lat=200, lon=-310, TrueProj=FALSE, # mit TrueProj=FALSE wird nun gesagt, dass nicht mehr die Koordinaten der # Map verwendet werden sollen, sondern die des Plot-Windows. Mit den beiden # Befehlen axis(1), axis(2) kann man sich die Achsen einzeichnen lassen und # sieht, dass sie jeweils von -320 bis 320 gehen. Dies liegt an der 640x640 # Auflösung. Standardmäßig ist TrueProj=TRUE. Nun wird die Legende bei # (x,y)=(-310,200) eingezeichnet. legend=c("2 Spiele", "1 Spiel"), col=c("brown","black"), lty=5, lwd=2, bg="gray98", cex=1.3) # Verschiedene Parameter zu Spezifikation der Legende werden noch angegeben. # Dasselbe Prozedere wird nun mit points und text auch ausgeführt PlotOnStaticMap(StadienMarker, FUN=points, add=TRUE, lat=DeutscheStadien$lat, lon=DeutscheStadien$lon-0.5, # den Längengrad hab ich um 0.5 Grad veschoben, damit der Kreis links neben # dem Stadion erscheint. cex=4, pch=16, col="chartreuse3") PlotOnStaticMap(StadienMarker, FUN=text, add=TRUE, lat=DeutscheStadien$lat, lon=DeutscheStadien$lon-0.5, # Ebenfalls um 0.5 verschoben, damit der Text auf dem Kreis erscheint. labels=DeutscheStadien$Tore, col=1,cex=1.5) # Als label werden die Anzahl der Tore verwendet die Deutschland in dem # Stadion geschossen hat. PlotOnStaticMap(StadienMarker, FUN=points, add=TRUE, lat=DeutscheStadien$lat, lon=DeutscheStadien$lon+0.5, cex=4, pch=16, col="indianred") PlotOnStaticMap(StadienMarker, FUN=text, add=TRUE, lat=DeutscheStadien$lat, lon=DeutscheStadien$lon+0.5, labels=DeutscheStadien$Gegentore, col=1,cex=1.5) PlotOnStaticMap(StadienMarker, FUN=legend, add=TRUE, lat=300, lon=-310, TrueProj=FALSE, legend=c("Anzahl der Tore","Anzahl der Gegentore"), pch=16, pt.cex=3, col=c("chartreuse3","indianred"), cex=1.3, bg="gray98") title("WM 2010 für die Deutschen") # Als Letztes folgt nur noch die Überschrift der Map. # Die Fertige Map zeigt nun auf einen Blick die Stadien der WM in Süafrika, # das Quartier der Deutschen, wie oft jeweils im Stadion gespielt wurde und # wieviel Tore und Gegentore geschossen wurden. ################################################################################ ## Fazit ##### ################################################################################ # Dies war nun eine Einführung in 4 Pakete die zum Themengebiet: "Kartographie # in R" gehören. sp ist ein Paket, welches eine Grundlage dafür schafft mit # räumlichen und GebietsDaten zu arbeiten. Die SpatialObjekte werden noch in # vielen weiteren KartographiePaketen verwendet und es wird empfohlen sich als # Erstes hiermit auseinanderzusetzen bevor man in das Themengebiet einsteigt. # Ein Paket was die SpatialObjekte verwendet ist zum Beispiel rworldmaps. Dieses # ist vor allem im Zusammenhang mit Visualisierungen auf Weltebene relevant und # kann Grafiken mit passenden Legenden erweitern. # Ein Paket was vorerst nichts mit Datenvisualisierung zu tun hat ist geonames. # Dieses hilft einen aber dabei Daten zu erhalten, weil es Suchanfragen an die # GEONAMES-Datenbank stellt. Das vierte Paket im Bunde ist RgoogleMaps. Es wird # dafür benutzt statische Maps vom GoogleMapsServer herunterzuladen um anschließend # auf ihnen zu plotten. Mit spatialObjekten hat es voerst nichtst zu tun. Aber # man kann bei Bedarf zum Beispiel auch maps aus anderen Paketen über die Satel- # litenbilder legen. # Zusammenfassend lässt sich sagen, dass das Ziel dieser Hausarbeit war eine kurze # Einführung in die 4 Pakete zu geben. Denn es gibt noch mehr Parameter und # Funktionen, die man hätte verwenden können. Dies würde aber über den Umfang # der Arbeit gehen. ################################################################################ ## Quellen ##### http://r-spatial.sourceforge.net/ [Stand: 17.01.2011] http://www.asdar-book.org/ [Stand: 17.01.2011] Bivand,R.S./Pebesma,E.J./Gómez-Rubio,V.: Applied Spatial Data Analysis with R, Springer, 2008 South,A. (2010), package: rworldmap [Ver 0.121] Rowlingson,B. (2008), package: geonames [Ver 0.8] Loecher,M. (2009), package: RgoogleMaps [Ver 1.1.9.4] Neuwirth,E. (2002), package: RColorBrewer [Ver 1.0-2] Brownrigg,R. (2003), package: mapdata [Ver 2.1-3] Brownrigg,R. (2003), package: maps [Ver 2.1-5] NGA: GeoidHeightFile, http://earth-info.nga.mil/GandG/wgs84/gravitymod/wgs84_180/wgs84_180.html [Stand: 17.01.2011] Google (2011), Google Static Maps API: http://code.google.com/intl/de-DE/apis/maps/documentation/staticmaps/ [Stand: 17.01.2011] Iplaces (2010), StadienKoordinaten: http://www.iplaces.co.za/index.php?option=com_content&view=article&id=64:world-cup-2010-south-africa-stadium-gps-coordinates&catid=37:general [Stand: 17.01.2011]