Linientypen, Symbole und Farben in R-Plots

R bietet verschiedene Möglichkeiten, seine Datenreihen in Plots unterscheidbar zu machen. Dazu gibt man in den Plot-Befehlen den zu ändernden Parameter, sowie einen Zahlenwert an. Ich vergesse allerdings immer, welche Zahl zu welcher Farbe oder zu welchem Linientyp gehört. Daher liste ich in diesem Artikel Zahlenwerte für folgende Parameter auf:

  1. Typen von Linien (lty).
    Beispiel: plot(c(1:10), type="o", lty=3).
  2. Farben (col).
    Beispiel: plot(c(1:10), type="o", col=4).
  3. Typen von Punkten / Sybole (pch; point character).
    Beispiel: plot(c(1:10), type="o", pch=5).

Linientypen

In R gibt es sechs verschiedene Typen von Linien. Die Zahlen für die Linientypen werden mit einer Periode von sechs „recycled“. Dadurch entspricht der Typ sieben (7) wieder dem Typen eins (1), eine Linie vom Typ acht (8) sieht aus wie eine Linie vom Typen zwei (2) und so weiter. Für jeden der Linien-Typen gibt es auch einen Namen (siehe auch Beschreibung des Parameters lty in der R-Hilfe zu par(): ?par):

  • 0: „blank“; unsichtbare Linie (=> wird nicht gezeichnet)
  • 1: „solid“
  • 2: „dashed“
  • 3: „dotted“
  • 4: „dotdash“
  • 5: „longdash“
  • 6: „twodash“
In R gibt es sechs verschiedene Typen von Linien, hier abwechselnd in rot und grün dargestellt. Jeder der Linientypen ist in 3 verschiedenen Größen (lwd=1-3) dargestellt. Die Werte für die Linientypen wiederholen sich in einer Periode von sechs. Daher entspricht die Angabe lty=7 der Angabe lty=1, die Angabe lty=8 entspricht der Angabe lty=2, und so weiter.
In R gibt es sechs verschiedene Typen von Linien, hier abwechselnd in rot und grün dargestellt. Jeder der Linientypen ist in 3 verschiedenen Größen (lwd=1-3) dargestellt. Die Werte für die Linientypen wiederholen sich in einer Periode von sechs. Daher entspricht die Angabe lty=7 der Angabe lty=1, die Angabe lty=8 entspricht der Angabe lty=2, und so weiter.

Das oben stehende Bild habe ich mit folgendem Code erzeugt:

1
2
3
4
5
6
7
8
# 6 Linientypen
png("linientypen.png")
par(mar=c(0,4,0,0)+.1, cex=1.5)
plot(1,1, type="n", ylim=c(0, 7), xaxt="n", xlab="", ylab="Linentyp (lty)", las=1)
abline(h=c(0:7),     lty=c(0:7), lwd=3, col=c(2,3))
abline(h=c(0:7)-0.2, lty=c(0:7), lwd=2, col=c(2,3))
abline(h=c(0:7)-0.4, lty=c(0:7), lwd=1, col=c(2,3))
dev.off()

Farben

In der Standard-Palette von R befinden sich acht verschiedene Farben. Dazu kommt noch der Wert 0, bei dem die Hintergrundfarbe als Farbe verwendet wird. Die Farben werden mit einer Periode von acht „recycled“. Durch diese fortlaufende Wiederholung, entspricht die Farbe neun (9) der Farbe eins (1), die Farbe zehn (10) wieder der Farbe zwei (2) und so weiter. Anstatt einer Zahl kann man auch direkt den RGB-Farbwert angeben (z.B. plot(1, 1, col="#000000") anstatt plot(1, 1, col=1) ). Weitere Details gibt es im Bereich „Color Specification“ in der R-Hilfe zu den Grafik-Parametern (?par).

In R gibt es acht verschiedene Farben. Hinzu kommt der Wert 0, bei dem die Hintergrundfarbe als Farbe verwendet wird (siehe diagonale Linie). Mit einer Periodenlänge von 8, werden die Farben wiederholt (wiederholte Farben sind mit einer dünnen Linie dargestellt).
In R gibt es acht verschiedene Farben. Hinzu kommt der Wert 0, bei dem die Hintergrundfarbe (hier: #eeeeee) als Farbe verwendet wird (siehe diagonale Linie). Mit einer Periodenlänge von 8, werden die Farben wiederholt (wiederholte Farben sind mit einer dünnen Linie dargestellt).

Für das vorangegangene Bild habe ich folgenden Code verwendet:

1
2
3
4
5
6
7
# 8 LinienFarben
png("linienfarben.png")
par(mar=c(0,4,0,0)+.1, cex=1.5, bg="#eeeeee")
plot(1,1, type="n", ylim=c(0, 11), xlim=c(0, 11), xaxt="n", xlab="", ylab="Linenfarbe (col)", las=1, lab=c(1,11,0))
abline(h=c(0:11), lty=1, lwd=c(rep(10,9), rep(1,9)), col=c(0:11))
abline(a=0, b=1, lwd=10, col=0)
dev.off()

Punkttypen / Symbole

Um den Punkttyp zu definieren, kann entweder ein einzelnes Zeichen oder eine Zahl angeben werden. In der Hilfe zum Befehl par() (?par oder ?graphics::par) steht dazu:

Note that only integers and single-character strings can be set as a graphics parameter (and not NA nor NULL)

Eine detaillierte Liste gibt es in der R-Hilfe zur Funktion points() (?points; Bereich „‚pch‘ values“). Hier eine kurze Zusammenfassung:

  • Zeichen 018: S-kompatible Vektor Symbole
  • Zeichen 1925: Weitere R Vektor Symbole. Die Zeichen 2125 können mit Hilfe von bg innerhalb des plot-Befehls (hier: points()) eingefärbt werden. Achtung: Die Angabe von bg innerhalb von points() hat hier eine andere Auswirkung als die Angabe von bg innerhalb von par() (z.B. par(bg="#ff00ff")). Durch letzteres setzt man die Hintergrundfarbe der gesamten Plot-Fläche.
  • Zeichen 2631: Werden ignoriert
  • Zeichen 32127: ASCII Zeichen

In der folgenden Grafik werden die die ersten 26 Zeichen dargestellt (+ zwei negative Werte).

Punkt-Typen für "pch"-Werte von -2 bis +25. Der Innernraum der Zeichen 21 bis 25 wurde durch die Angabe " bg='red' " innerhalb des Befehls "points()" rot eingefärbt.
Punkt-Typen für „pch“-Werte von -2 bis +25. Der Innernraum der Zeichen 21 bis 25 wurde durch die Angabe “ bg=’red‘ “ innerhalb des Befehls „points()“ rot eingefärbt.

Das oben stehende Bild wurde mit folgenden Befehlen erzeugt:

1
2
3
4
5
6
7
8
9
# 25 Punkt-Typen
png("punkttypen.png")
par(mar=c(0,4,0,0)+.25, cex=1.5)
plot(1, 1, type="n", ylim=c(-2, 25), xlim=c(0, 10), xaxt="n", xlab="", ylab="Punkttyp (pch)", las=1, lab=c(2,15,0))
abline(h=c(-2:25), lty=3, lwd=1, col="#cccccc")
for (typ in -2:25) {
  points(x=c(0:10), y=c(rep(typ,11)), pch=typ, bg="red")
}
dev.off()

Fehlerbalken in R-Grafik einzeichnen

In wissenschaftlichen Publikationen werden häufig Messwerte in Grafiken dargestellt. Messungen sind allerdings immer fehlerbehaftet. Daher sollte man dem Leser mitteilen, wie verlässlich die gemessenen Werte sind. In der deskriptiven Statistik gibt es dafür diverse Kennzahlen, wie z.B. die Standardabweichung oder den Standardfehler. Diese werden oft als Fehlerbalken in die Grafiken eingefügt.

errorbars
Grafisch dargestellte Messwerte mit Fehlerbalken.

In R gibt es leider keine Standardmethode, die diese Aufgabe übernimmt. Zunächst hatte ich nach Anleitungen im Internet eigene Funktionen für diese Aufgabe erstellt.

  • Eine Lösung fand ich bei Stackoverflow. Allerdings wurden hier die horizontalen Linien bei einer logarithmischen X-Achse nicht korrekt angezeigt (links und rechts waren die Linien unterschiedlich lang).
  • Die Lösung von MonkeysUncle war in der Hinsicht besser. Allerdings wurde keine horizontale Linie angezeigt, wenn der Fehler 0 war. Zudem wurde gar kein Fehlerbalken angezeigt, wenn die untere Grenze des Fehlers (bei logarithmischer Y-Achse) im negativen Bereich lag.

Schließlich habe ich die Funktion errbar() im Paket Hmisc gefunden (siehe auch StackOverflow). Hier werden:

  1. Die horizontalen Linien auch bei logarithmischer X-Achse korrekt gezeichnet.
  2. Bei logarithmischer Y-Achse und negativer unteren Fehlergrenze, wird zumindest die obere Fehlergrenze geplottet.
  3. Eine horizontale Linie wird auch hinzugefügt, wenn der Fehler 0 ist.
  4. Die Y-Ranges werden automatisch gewählt, wenn die Fehlerbalken ausserhalb der Grafik liegen würden.

Das folgende Beispiel zeigt, wie man Datenpunkte mit ihren Fehlerbalken in eine Grafik einträgt.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# Datenpunkte (x, y) mit einer Standardabweichung (sd)
daten = data.frame(
  x  = c(1:5)
  , y  = c(1.1, 1.5, 2.9, 3.8, 5.2)
  , sd = c(0.2, 0.3, 0.2, 0.0, 0.4)
)
 
# Paket "Hmisc" installieren und laden 
install.packages("Hmisc", dependencies=T)
library("Hmisc")
 
# Plot mit automatischer Wahl des Y ranges
with (
  data = daten
  , expr = Hmisc::errbar(x, y, y+sd, y-sd, pch=1)
)
 
# Datenpunkte mit Fehlerbalken zu einem
# existierenden Koordinatensystem hinzufügen (add=T)
plot(daten$x, daten$y, type="n", xlab="X-Werte", ylab="Y-Werte")
with (
  data = daten
  , expr = Hmisc::errbar(x, y, y+sd, y-sd, pch=2, add=T)
)

Die Funktion errbar() erweitert die Funktion plot(). Daher können die Grafikparameter von plot() und par() (hier z.B. pch) verwendet werden. Zusätzlich gibt es noch Parameter, mit denen sich z.B. die breite der horizontalen Begrenzung (cap) steuern lässt.

Funktion aus einem bestimmten R-Paket laden

Die Programmiersprache R kann durch Funktionen erweitert werden, die von anderen Nutzern erstellt wurden. Oftmals sind diese Erweiterungen in Paketen zusammengefasst. Ein Problem tritt allerdings dann auf, wenn in unterschiedlichen Paketen Funktionen enthalten sind, die den gleichen Namen tragen (siehe: Stackoverflow).

Ich nutze z.B. folgende Pakete sehr häufig:

  • sfsmisc – Mit der Funktion eaxis() lassen sich schöne logarithmische Achsen erstellen. Die Beschriftung wird dabei von der Funktion pretty10exp() übernommen.
  • Hmisc– Mit der Funktion errbar() lassen sich sehr leicht Fehlerbalken in Plots eintragen.
  • TeachingDemos – Mit der Funktion subplot() lassen sich sehr einfach Insets zu Plots hinzufügen.

Lädt man allerdings die Pakete,

## Installation der Pakete
install.packages("sfsmisc", dependencies=T)
install.packages("Hmisc", dependencies=T)
install.packages("TeachingDemos", dependencies=T)
 
## Laden der Pakete
library(package = "sfsmisc")
library(package = "Hmisc")
library(package = "TeachingDemos")

dann erhält man folgende Fehlermeldungen:

Attache Paket: ‘Hmisc’

Das folgende Objekt ist maskiert from ‘package:survival’:
    untangle.specials

Das folgende Objekt ist maskiert from ‘package:sfsmisc’:
    errbar

Das folgende Objekt ist maskiert from ‘package:base’:
    format.pval, round.POSIXt, trunc.POSIXt, units

Man kann erkennen, dass sowohl Hmisc als auch sfsmisc eine Funktion namens errbar() enthalten.

Attache Paket: ‘TeachingDemos’

Das folgende Objekt ist maskiert from ‘package:Hmisc’:
    cnvrt.coords, subplot

Man kann erkennen, dass sowohl TeachingDemos als auch Hmisc eine Funktion mit Namen subplot() enthalten.

Um nun die Funktion aus einem bestimmten Paket zu verwenden, kann man R dies mit Hilfe von zwei Doppelpunkten :: mitteilen:

# Verwende die Funktion subplot() aus dem Paket TeachingDemos
TeachingDemos::subplot(...)
 
# Verwende die Funktion errbar() aus dem Paket Hmisc
Hmisc::errbar(...)

Meine Empfehlung: Wenn man Funktionen aus einem Paket verwendet, sollte man beim Aufruf der Funktion immer diese Notation verwenden. Zum einen hilft es dem Leser zu erkennen, woher diese Funktion stammt. Zum anderen verhindert man unnötige Verwirrung, wenn man zu einem späteren Zeitpunkt Pakete einbindet, die Funktionen mit gleichem Namen enthalten.

Plot-Funktion in R erweitern

Manchmal möchte man eine bestehende Funktion in der Programmiersprache R um einen eigenen Parameter erweitern. Die Parameter der Ausgangsfunktion sollen dabei einfach übernommen werden, ohne sie innerhalb der eigenen Funktion definieren und einzeln übergeben zu müssen. Die Weiterleitung von Parametern kann in R durch ... realisiert werden.

Im folgenden Beispiel erweitere ich die R-Funktion plot(). In der neuen Funktion plot.mein() kann zusätzlich eine rote horizontale und/oder vertikale Linie eingezeichnet werden.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# Definition der neuen Funktion
plot.mein <- function(..., hline=NULL, vline=NULL) {
  # Plote die Daten
  # Leite die Grafik-Parameter direkt an die Funktion plot() weiter
  plot(...)
 
  # Füge eventuell eine horizontale rote Linie hinzu
  if(!is.null(hline)) {
    abline(h=hline, col="#ff0000")
  }
 
  # Füge eventuell eine vertikale rote Linie hinzu
  if(!is.null(vline)) {
    abline(v=vline, col="#ff0000")
  }
}
# Die Parameter x, y und type werden direkt an die Funktion plot weitergeleitet
plot.mein(c(1:6), c(16:11), hline=3, vline=2, type="b")
 
# Wenn die Namen der Parameter angegeben werden,
# dann spielt auch die Reihenfolge beim Aufruf keine Rolle
plot.mein(hline=3, x=c(1:6), vline=2, y=c(16:11), type="b")

Man kann auch die Standard-Parameter der Ausgangsfunktion ändern. Dazu muss der Parameter in der Definition der eigenen Funktion mit dem gewünschten Wert eingetragen werden (hier: type="o"). Der Parameter muss zusätzlich explizit an die Ausgangsfunktion übergeben werden (hier: type=type).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Ändere den Standardwert für type
plot.mein <- function(..., hline=NULL, vline=NULL, type="o") {
  # type muss explizit übergben werden
  plot(..., type=type)
 
  # [...]
 
}
 
# Der in plot.mein() festgelegte Standadwert für type ("o") wird verwendet
plot.mein(c(1:6), c(16:11), hline=3, vline=2)
 
# Hier wird der beim Aufruf angegebene Wert für type ("b") verwendet
plot.mein(c(1:6), c(16:11), hline=3, vline=2, type="b")