###############################################################################
## Inhalt: 
## Kapitel 4 (Graphiken) des R-Kurses von Ruckdeschel & Kohl
###############################################################################

###############################################################################
## 4. Graphiken
###############################################################################
###############################################################################
## 4.1 Ausgabegeräte (Devices)
###############################################################################
## Wenn wir eigene Graphiken erstellen wollen, wollen wir zuerst einmal wissen,
## welche Möglichkeiten uns unser System bietet. Die möglichen Ausgabegeräte
## heißen Devices, also
?Devices

## Die Default-Graphik-Möglichkeiten von R sind im Paket 'grDevices' 
## abgelegt
library(help = 'grDevices')

## Welche Device wird geöffnet, wenn Sie auf Ihrem System einen Plot erzeugen?
getOption('device')

## Auf einem X-Windows System (Linux, Windows) funktioniert, öffnet
x11() ## oder X11()
## eine neue Device

## Falls Sie eine Funktion schreiben wollen, die Graphiken ausgibt und diese
## platformunabhängig funktionieren soll, dann z.B. nicht X11, sondern
get(getOption('device'))()
## verwenden!!!

## Für den Zugriff (Öffnen, Schließen, Auswählen, etc.) von Devices sind die 
## Funktionen dev.cur (aktuelle Device), dev.list (alle offenen Devices),
## dev.next (Auswahl der nächsten offenen Device), 
## dev.prev (Auswahl der vorgehenden offenen Device),
## dev.off (Beenden einer Device)
## dev.set (Bestimmte Device auf 'aktiv' setzen)
## graphics.off (Beenden aller offenen Devices)
dev.list()
dev.cur()

## Zum Befehl curve später mehr ...
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2) ## Glockenkurve

dev.next() ## zyklisch

curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 'orange') ## Glockenkurve
dev.set(which = 3)

graphics.off() ## beendet beide Devices, dev.off() nur die aktuelle

## Die Funktionen zum Aufruf der Devices besitzen verschiedene zusätzliche
## Parameter
x11(width = 5, height = 5) ## Größe des Graphikfensters in inches

## Wollen Sie inches in Zentimeter umrechnen, so können Sie die Funktion 'cm'
## verwenden
cm(5)

curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 'orange') ## Glockenkurve

## Der Default Hintergrund ist 'transparent'. 
## Die weiße Farbe, die man sieht ist die canvas-Farbe, welche jedoch nicht
## mit exportiert wird, falls man die Graphik abspeichert.
## Will man auch dann einen weißen Hintergrund haben, so muss man diesen
## explizit setzen
x11(width = 6, height = 6, bg = 'white') 
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 'orange') ## Glockenkurve

## Vergleiche
x11(width = 6, height = 6, bg = 'orange', canvas = 'black') 
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 'blue') ## Glockenkurve

## Darüberhinaus gibt es Möglichkeit die Punktgröße oder die Schriftart
## zu steuern sowie Farbkorrekturen vorzunehmen (gamma-Faktor).
##
## Jede Device hat gewisse Default-Einstellungen, die durchaus zwischen
## den Devices etwas verschieden sind. Außerdem besitzen die unterschiedlichen
## Devices auch leicht unterschiedliche Einstellungsmöglichkeiten.
graphics.off()

## Die postscript-Device stellt eine gewisse Besonderheit dar, neben der 
## Funktion postscript, können mittels der Funktion ps.options Einstellungen
## festgelegt bzw. verändert werden.
## postscript (.ps, bzw. .eps) ist ein Vektorgraphik-Format und kann somit
## auch nach dem Abspeichern noch jederzeit umskaliert werden.
## Es eignet sich somit besonders für Poster oder andere 'Marketingunterlagen'.

## Zum Abschluss erzeugen wir noch eine png-Datei, die wir dann problemlos
## in OpenOffice, MS-Office, HTML, LaTeX, etc. weiterverwenden könnten.
png(file = 'Glockenkurve.png')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 'orange', 
xlab = 'Standardeinheiten', ylab = 'Anteil je Standardeinheit', 
main = 'Gaußsche Glockenkurve') ## Glockenkurve
dev.off()

## Nun finden Sie im aktuellen Arbeitsverzeichnis von R die Datei
## 'Glockenkurve.png'. 
?getwd
getwd()

## Unter Windows stimmt das aktuelle Arbeitsverzeichnis 
## per Default mit dem Verzeichnis überein, in dem R installiert ist.
R.home()

## Unter Windows können Sie das Arbeitsverzeichnis abändern
## mittels dem Menüpunkt Datei/File -> Change dir...
## oder aber auch über 
?setwd
## Bsp: setwd('C:\\work\\Softwarebegleitung\\Homework')
## Achtung: Sie müssen '\\' verwenden und nicht nur '\'
## oder aber
## setwd('C:/work/Softwarebegleitung/Homework')


###############################################################################
## 4.2 Die Funktion plot und ihre Verwandten
###############################################################################
## Die Standardfunktion, mit der in R Graphiken erzeugt werden ist 'plot'.
## Diese Funktion besitzt eine große Anzahl von Parametern. 
?plot

## Hinzukommen eine Vielzahl von weiteren Parametern, welche über die Funktion 
## 'par' gesteuert werden können.
?par
length(par()) ## Anzahl der zur Verfügung stehenden Parameter

## Häufiger benutzte Parameter
## cex, cex.axis, cex.lab, cex.main, cex.sub: Festlegung der Schriftgröße
## bei Beschriftungen
## col, col.axis, col.lab, col.main, col.sub: Farbe der Beschriftung
colors()

## Man kann aber auch jederzeit neue Farben definieren. 
## Hierfür gibt es die Funktionen
## rgb, hsv, gray/grey, rainbow, heat.colors, topo.colors, terrain.colors, 
## cm.colors, col2rgb
## und einige andere
## Interessant: www.colorbrewer.org
## Im R-Paket 'RColorBrewer' implementiert.
library(RColorBrewer)
display.brewer.all(n=5)

## font, font.axis, font.lab, font.main, font.sub: Schriftart
## las: Ausrichtung der Achsenbeschriftung
## lty: Linientyp, der bei Linienplots verwendet wird
plot(c(-1, 8), c(-1, 8), type = 'n', ylab = 'Linientyp', xlab = '')
abline(h = 0, lwd = 2, lty = 0)
abline(h = 1, lwd = 2, lty = 1)
abline(h = 2, lwd = 2, lty = 2)
abline(h = 3, lwd = 2, lty = 3)
abline(h = 4, lwd = 2, lty = 4)
abline(h = 5, lwd = 2, lty = 5)
abline(h = 6, lwd = 2, lty = 6)
## es können auch jederzeit neue Linientypen erzeugt werden;
## siehe Abschnitt 'Line Type Specification' in ?par
abline(h = 7, lwd = 2, lty = '5394')

## lwd: Strichstärke bei Plots
## mar: Ränder um den Plot herum (Anzahl von Linien auf den jeweiligen Seiten
##      des Plots
## mfrow, mfcol: Aufteilung einer Device in mehrere Spalten und Zeilen
## pch: Punkttyp, der bei Scatterplots verwendet wird; vgl. auch ?points
example(points)

## xlog, ylog: x- bzw. y-Achse mit logarithmischer Skala

## Die Funktion plot selbst hat zusätzlich die wichtigen Argumente
## type: Art des Plots (Linien, Punkte, beides, Treppenfunktion, ...)
## main: Überschrift
## sub: Unterüberschrift
## xlab: x-Achsenbeschriftung
## ylab: y-Achesnbeschriftung
## axes: Sollen Achsen gezeichnet werden?
## xlim: Wertebereich der x-Achse
## ylim: Wertebereich der y-Achse
x <- seq(from = -4, to = 4, length = 500)
plot(x, dnorm(x), type = 'l', main = 'Gaußsche Glockenkurve', 
sub = 'Standardnormalverteilung', xlab = 'Standardeinheiten',
ylab = 'Anteil pro Standardeinheit', axes = TRUE, xlim = c(-5, 5),
ylim = c(0, 0.5), col = 'orange', lwd = 2)

## Setzt man axes = FALSE, so kann man mit Hilfe der Funktionen
## axis und box nachträglich die Achsen und deren Beschriftung
## selbst auswählen und einzeichnen.
## Zum nachträglichen Einzeichnen von Linien, Punkten oder Symbolen 
## in bestehende Plots sind die Funktionen 'lines', 'abline', 
## 'points' und 'symbols' vorgesehen
## Zusätzlichen Text kann man mit den Funktionen 'text', 'mtext',
## 'legend' oder 'title' ergänzen.
## In diesem Zusammenhang könenn auch mathematische Symbole 
## verwendet werden; vgl. 'plotmath'

## Wir haben oben ja bereits die Funktion curve verwendet.
## Die Benutzung von 'curve' ist immer dann angebracht, wenn
## man sich ohne großen Aufwand eine Funktion ansehen will.
## Die Funktion 'curve' generiert dann den entsprechenden 
## Aufruf von 'plot'
## Das letzte Beispiel wäre dann kürzer:
curve(dnorm, from = -4, to = 4, n = 500, main = 'Gaußsche Glockenkurve', 
sub = 'Standardnormalverteilung', xlab = 'Standardeinheiten',
ylab = 'Anteil pro Standardeinheit', axes = TRUE, xlim = c(-5, 5),
ylim = c(0, 0.5), col = 'orange', lwd = 2)


## Es gibt noch eine Vielzahl weiterer Funktionen zum Erzeugen von
## Graphiken, die wir zum Teil noch im Laufe der Vorlesungen kennenlernen
## werden; vgl. Skript zum R-Kurs.
## So sind in R neben dem Default-Graphik-System auch noch andere 
## Graphik-Systeme implementiert. Insbesondere Trellis-Graphik
## (R-Pakete: grid, lattice), welche insbesondere bei komplexeren 
## Graphiken mehr Möglichkeiten bietet als das Default-System.
## 'Grammar of Graphics' in den R-Paketen ggplot, ggplot2
## 'gRaphical models in R' im Projekt gR (vgl. http://www.ci.tuwien.ac.at/gR/)
## Schnittstelle zu GGobi (vgl. http://www.ggobi.org/) mittels Paket rggobi
## Viele schöne Bilder finden sich unter: http://addictedtor.free.fr/graphiques/
## Neben den Bildern ist dort auch der Code angegeben, mit dem
## diese generiert wurden.

###########################################################
## Aufteilung einer Device
###########################################################
#######################################
## 1. Möglichkeit: Verwende die Parameter mfrow oder mfcol von par
#######################################
## Dies erzeugt eine Device, die in gleich große Felder aufgeteilt
## wird. Ein einfaches Beispiel
par(mfrow = c(2, 3)) ## zeilenweise
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 1, main = 'Plot 1')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 2, main = 'Plot 2')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 3, main = 'Plot 3')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 4, main = 'Plot 4')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 5, main = 'Plot 5')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 6, main = 'Plot 6')

## oder
x11()
par(mfcol = c(2, 3)) ## spaltenweise
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 1, main = 'Plot 1')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 2, main = 'Plot 2')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 3, main = 'Plot 3')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 4, main = 'Plot 4')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 5, main = 'Plot 5')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 6, main = 'Plot 6')


#######################################
## 2. Möglichkeit: Verwende layout - flexibler als 'mfrow'/'mfcol'
#######################################
## Durch Angabe einer Matrix läßt sich eine Device sehr flexibel
## in verschiedene Plot-Regionen aufteilen.
## Es können maximal 50 Zeilen bzw. Spalten generiert werden.
## Insgesamt kann eine Device in maximal 500 Felder unterteilt werden.
layout(matrix(c(1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 4, 4), ncol = 2))

## Das Layout kann man sich anschließend anzeigen lassen 
layout.show(n = 4)
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 1, main = 'Plot 1')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 2, main = 'Plot 2')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 3, main = 'Plot 3')
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 4, main = 'Plot 4')


#######################################
## 3. Möglichkeit: Verwende split.screen 
## Anderer Ansatz, sehr flexibel ...
## Achtung: Die Funktion 'split.screen' ist nicht verträglich mit 'par(mfrow)', 
## 'par(mfcol)' oder 'layout'!!!
#######################################
## Es gibt zwei Möglichkeiten:
## Man kann 'split.screen' mit einem Vektor der Länge 2 oder einer Matrix mit 
## 4 Spalten aufrufen. Beim Aufruf mit einen Vektor der Länge 2 'c(x1, x2)' wird 
## der aktuelle screen (falls bereits einer vorhanden ist) oder aber die aktuelle 
## Device in x1 Zeilen und x2 Spalten unterteilt. 
## Durch den Aufruf der 'split.screen' Funktion wird R in den split-screen Modus
## versetzt. Die nun folgenden screen-Funktionen arbeiten nur in diesem Modus.
## Der Zugriff auf die erstellten screens erfolgt mittels der Funktion 'screen'.
## Mit 'erase.screen' kann der ausgewählte screen gelöscht/geleert werden und
## mit 'close.screen' kann der ausgewählte oder alle (Parameter 'all.screens = TRUE')
## screens geschlossen werden.
par(bg = 'white') ## damit die volle screen-Funktionalität vorhanden ist,
                  ## darf der Background nicht 'transparent' sein!
split.screen(figs = c(2, 2))
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 1, main = 'Plot 1')
screen(n = 2)
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 2, main = 'Plot 2')
screen(n = 3)
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 3, main = 'Plot 3')
screen(n = 4)
split.screen(figs = c(1, 2))
screen(n = 5)
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 4, main = 'Plot 4')
screen(n = 6)
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 5, main = 'Plot 5')
erase.screen(n = 3) ## wird mit der Background-Farbe ``übermalt''
                    ## Funktioniert daher nicht mit 'transparent'
screen(n = 3)
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 6, main = 'Plot 6')
close.screen(all.screens = TRUE)
dev.off()

## Beim Aufruf mit einer Matrix (4 Spalten!) beschreibt jede Zeile einen 
## screen. Jede Zeile enthält Werte in [0,1], welche die Position des screen 
## beschreiben.
## 1. Zahl: Position des linken Randes von links gemessen
## 2. Zahl: Position des rechten Randes von links gemessen
## 3. Zahl: Position des unteren Randes von unten gemessen
## 4. Zahl: Position des oberen Randes von unten gemessen
split.screen(matrix(c(0, 0.3, 0.6, 1, 
                      0.3, 0.6, 0.4, 1, 
                      0.6, 1, 0, 1, 
                      0, 0.3, 0, 0.6, 
                      0.3, 0.6, 0, 0.4), ncol = 4, byrow = TRUE))
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 1, main = 'Plot 1')
screen(n = 2)
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 2, main = 'Plot 2')
screen(n = 3)
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 3, main = 'Plot 3')
screen(n = 4)
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 4, main = 'Plot 4')
screen(n = 5)
curve(dnorm, from = -4, to = 4, n = 500, lwd = 2, col = 5, main = 'Plot 5')
close.screen(all.screens = TRUE)
dev.off()


###############################################################################
## Univariate Diagramme
###############################################################################
###########################################################
## 1. Histogramm, empirische Verteilungsfunktion, Boxplot
## Werden wir später behandeln
###########################################################

###########################################################
## 2. Säulendiagramm
## Die Funktion, um Säulendiagramme zu erstellen, ist 'barplot'
## Wir orientieren uns an 'example(barplot)'
?barplot
?VADeaths
barplot(VADeaths)
barplot(VADeaths, space = 1)
barplot(VADeaths, beside = TRUE)

## Hinzufügen von Text
mp <- barplot(VADeaths) # default
tot <- colMeans(VADeaths)
text(mp, tot + 3, format(tot), xpd = TRUE, col = "blue")

## Mit Legende und Farbgebung
barplot(VADeaths, beside = TRUE,
        col = c("lightblue", "mistyrose", "lightcyan",
                "lavender", "cornsilk"),
        legend = rownames(VADeaths), ylim = c(0, 100))
title(main = "Death Rates in Virginia", font.main = 4)

## zusätzlich 'obere Konfidenzschranken'
## besser hierfür geignet: Funktion 'barplot2' auf Paket 'gplots'
hh <- t(VADeaths)[, 5:1]
mybarcol <- "gray20"
mp <- barplot(hh, beside = TRUE,
             col = c("lightblue", "mistyrose",
                     "lightcyan", "lavender"),
             legend = colnames(VADeaths), ylim= c(0,100),
             main = "Death Rates in Virginia", font.main = 4,
             sub = "Faked upper 2*sigma error bars", col.sub = mybarcol,
             cex.names = 1.5)
segments(mp, hh, mp, hh + 2*sqrt(1000*hh/100), col = mybarcol, lwd = 1.5)
stopifnot(dim(mp) == dim(hh))# corresponding matrices
mtext(side = 1, at = colMeans(mp), line = -2,
           text = paste("Mean", formatC(colMeans(hh))), col = "red")

## Schraffierungen
barplot(VADeaths, angle = 15+10*1:5, density = 20, col = "black",
             legend = rownames(VADeaths))
title(main = list("Death Rates in Virginia", font = 4))

## Säulenränder
barplot(VADeaths, border = "dark blue") 


###########################################################
## 3. Punktdiagramm
## Punktdiagramme lassen sich mit der Funktion 'dotchart' erstellen.
dotchart(VADeaths, main = "Death Rates in Virginia - 1940")
dotchart(t(VADeaths), main = "Death Rates in Virginia - 1940")


###########################################################
## 4. Kreis-/Kuchen-/Tortendiagramm
## Kuchendiagramme lassen sich mit der Funktion 'pie' erzeugen.
## Einige Möglichkeiten mit 'pie'
pie(rep(1, 24), col = rainbow(24), radius = 0.9)
pie.sales <- c(0.12, 0.3, 0.26, 0.16, 0.04, 0.12)
names(pie.sales) <- c("Blueberry", "Cherry",
    "Apple", "Boston Cream", "Other", "Vanilla Cream")
pie(pie.sales) ## default colours
pie(pie.sales, col = c("purple", "violetred1", "green3", "cornsilk", "cyan", "white"))
pie(pie.sales, col = gray(seq(0.4,1.0,length=6)))
pie(pie.sales, density = 10, angle = 15 + 10 * 1:6)

#######################################
## Achtung: Von Kreisdiagrammen ist abzuraten!!!
## Die R-Hilfe sagt hierzu:
## Pie charts are a very bad way of displaying information. 
## The eye is good at judging linear measures and bad at judging 
## relative areas. A bar chart or dot chart is a preferable way 
## of displaying this type of data.
#######################################


###########################################################
## Es gibt verschiedene Pakete, die zu den Standardplotfunktionen
## zusätzliche Funktionalität hinzugefügt haben; vgl. z.B.
## die Pakete 'gplots' und 'plotrix'
###########################################################
library(help = gplots)
library(help = plotrix)


###############################################################################
## Multivariate Diagramme
###############################################################################
###########################################################
## 1. Scatterplot-Matrizen
## Es wird jede Variable gegen jede abgetragen. In R läßt sich dies mittels
## der Funktion 'pairs' bewerkstelligen.
pairs(iris[1:4], main = 'Anderson Iris Data -- 3 species', pch = 21, 
bg = c("red", "green3", "blue")[unclass(iris$Species)])

## Angabe mittels einer Formel
## Zur Formelsyntax kommen wir später im Kurs
?swiss
pairs(~ Fertility + Education + Catholic, data = swiss, subset = Education < 20, 
main = "Swiss data, Education < 20")

## noch ein Beispiel
pairs(USJudgeRatings)


## Weitere Funktionalität: Hier nicht im Detail erklärt
## nur zur Demonstration der Möglichkeiten
## Histogramme auf der Diagonalen
panel.hist <- function(x, ...){
  usr <- par("usr"); on.exit(par(usr))
  par(usr = c(usr[1:2], 0, 1.5) )
  h <- hist(x, plot = FALSE)
  breaks <- h$breaks; nB <- length(breaks)
  y <- h$counts; y <- y/max(y)
  rect(breaks[-nB], 0, breaks[-1], y, col="cyan", ...)
}
pairs(USJudgeRatings[1:5], panel=panel.smooth, cex = 1.5, pch = 24, 
  bg="light blue", diag.panel=panel.hist, cex.labels = 2, font.labels=2)

## Betrag der Korrelation im oberen Bereich
## Schriftgröße proportional zur Korrelation
panel.cor <- function(x, y, digits=2, prefix="", cex.cor){
  usr <- par("usr"); on.exit(par(usr))
  par(usr = c(0, 1, 0, 1))
  r <- abs(cor(x, y))
  txt <- format(c(r, 0.123456789), digits=digits)[1]
  txt <- paste(prefix, txt, sep="")
  if(missing(cex.cor)) cex <- 0.8/strwidth(txt)
  text(0.5, 0.5, txt, cex = cex * r)
}
pairs(USJudgeRatings, lower.panel=panel.smooth, upper.panel=panel.cor)


###########################################################
## 2. Plotten von Matrizen gegeneinander
## Mit Hilfe von 'matplot' lassen sich die Spalten einer Matrix
## gegen die Spalten einer anderen Matrix plotten
matplot((-4:5)^2, main = "Quadratic") # almost identical to plot(*)

sines <- outer(1:20, 1:4, function(x, y) sin(x / 20 * pi * y))
matplot(sines, pch = 1:4, type = "o", col = rainbow(ncol(sines)))

matplot(sines, type = "b", pch = 21:23, col = 2:5, bg = 2:5,
             main = "matplot(...., pch = 21:23, bg = 2:5)")

x <- 0:50/50
matplot(x, outer(x, 1:8, function(x, k) sin(k*pi * x)),
             ylim = c(-2,2), type = "plobcsSh",
             main= "matplot(,type = \"plobcsSh\" )")

## pch & type =  vector of 1-chars :
matplot(x, outer(x, 1:4, function(x, k) sin(k*pi * x)),
             pch = letters[1:4], type = c("b","p","o"))

table(iris$Species) # is data.frame with 'Species' factor
iS <- iris$Species == "setosa"
iV <- iris$Species == "versicolor"
op <- par(bg = "bisque")
matplot(c(1, 8), c(0, 4.5), type= "n", xlab = "Length", ylab = "Width",
             main = "Petal and Sepal Dimensions in Iris Blossoms")

## Hinzufügen von Punkten
matpoints(iris[iS,c(1,3)], iris[iS,c(2,4)], pch = "sS", col = c(2,4))
matpoints(iris[iV,c(1,3)], iris[iV,c(2,4)], pch = "vV", col = c(2,4))
legend(1, 4, c("    Setosa Petals", "    Setosa Sepals",
                    "Versicolor Petals", "Versicolor Sepals"),
            pch = "sSvV", col = rep(c(2,4), 2))
## Das Hinzufügen von Linien ist mit 'matlines' möglich.

nam.var <- colnames(iris)[-5]
nam.spec <- as.character(iris[1+50*0:2, "Species"])
iris.S <- array(NA, dim = c(50,4,3), dimnames = list(NULL, nam.var, nam.spec))
for(i in 1:3) iris.S[,,i] <- data.matrix(iris[1:50+50*(i-1), -5])
matplot(iris.S[,'Petal.Length',], iris.S[,'Petal.Width',], pch='SCV',
             col = rainbow(3, start = .8, end = .1),
             sub = paste(c('S', 'C', 'V'), dimnames(iris.S)[[3]],
                         sep = "=", collapse= ",  "),
             main = 'Fishers Iris Data')
par(op)

###########################################################
## 3. Sternplot von Matrizen gegeneinander
###########################################################
data(mtcars)
stars(mtcars[, 1:7], key.loc = c(14, 2), 
  main = "Motor Trend Cars : stars(*, full = F)", full = FALSE)
stars(mtcars[, 1:7], key.loc = c(14, 1.5),
  main = "Motor Trend Cars : full stars()",flip.labels=FALSE)


## Spezialfall: 'Spider' oder 'Radar' plot:
stars(mtcars[, 1:7], locations = c(0,0), radius = FALSE,
  key.loc=c(0,0), main="Motor Trend Cars", lty = 2)


###########################################################
## 4. Symbolplots
###########################################################
x <- 1:10
y <- sort(10*runif(10))
z <- runif(10)
z3 <- cbind(z, 2*runif(10), runif(10))
symbols(x, y, thermometers=cbind(.5, 1, z), inches=.5, fg = 1:10)
symbols(x, y, thermometers = z3, inches=FALSE)
text(x,y, apply(format(round(z3, dig=2)), 1, paste, collapse = ","),
     adj = c(-.2,0), cex = .75, col = "purple", xpd=NA)


###############################################################################
## Flächendiagramme
###############################################################################
## Zur Visualisierung von dreidimensionalen Größen sind in R per default 
## drei Funktionen vorgesehen. Diese sind 
## 'persp': für perspektivische 3D-Plots
## 'contour': Plot von Niveaulinien
## 'image': farbcodierte Niveaulinien
## Diese drei Funktionen lassen sich auch miteinander kombinieren und
## man erhält eine Vielzahl von Möglichkeiten
demo(persp)
demo(image)

## Abgeleitet von 'image' ist die Funktion 'heatmap'
## Zusätzliche Funktionalität bietet die Funktion 'heatmap.2' aus dem Paket
## 'gplots'
## Zur Demonstration das Beispiel aus der Funktion 'heatmapCol' aus dem 
## Paket 'SLmisc', welches die Funktion 'heatmap.2' verwendet.
library(SLmisc)
data.plot <- matrix(rnorm(100*50, sd = 1), ncol = 50)
colnames(data.plot) <- paste("patient", 1:50)
rownames(data.plot) <- paste("gene", 1:100)
data.plot[1:70, 1:30] <- data.plot[1:70, 1:30] + 3
data.plot[71:100, 31:50] <- data.plot[71:100, 31:50] - 1.4
data.plot[1:70, 31:50] <- rnorm(1400, sd = 1.2)
data.plot[71:100, 1:30] <- rnorm(900, sd = 1.2)
nrcol <- 128
require(gplots)
require(RColorBrewer)
heatmap.2(data.plot, col =  rev(colorRampPalette(brewer.pal(10, "RdBu"))(nrcol)), 
  trace = "none", tracecol = "black")
farbe <- heatmapCol(data = data.plot, col =  rev(colorRampPalette(brewer.pal(10, "RdBu"))(nrcol)), 
  lim = min(abs(range(data.plot)))-1)
heatmap.2(data.plot, col = farbe, trace = "none", tracecol = "black")

###############################################################################
## Diese Beispiele zeigen nur eine kleine Auswahl der Möglichkeiten, die man
## mit R hat. Es gibt ein Vielzahl von Paketen, die zusätzlich Graphik-
## Funktionalität zur Verfügung stellen.
###############################################################################