Benjamin Bell: Blog

Graphic devices

R is able to output graphics to the screen or save them directly to a file (e.g. postscript, pdf, svg, png, jpeg etc.). The different functions for producing graphical output are known as "Devices". For example, pdf() would invoke the pdf device, while png() would invoke the png device. Type ?Devices into the R console to see a list of graphical devices that are available to R on your system.

By default, graphical output is sent to the screen. As R is cross-platform, the graphics device for producing "screen" graphics differs by system. The available fonts may also differ by system and graphical device.

For Windows, the default graphics device for outputting to screen is windows(). To see which fonts are available to the windows graphics device, type windowsFonts() into the R console (this code will only work on Windows systems).

For MacOS, the default graphics device for outputting to screen is quartz(). This device can also be used to create a number of graphics files on MacOS systems. To see the fonts available to the quartz graphics device, type quartzFonts() into the R console.

For Linux and UNIX systems, the default graphics device is X11() which outputs to screen. The X11() function is a wrapper for two devices: "Xlib" and "Cairo" graphics. Most pre-compiled R builds for Linux will default to Cairo graphics. To see the fonts available to the X11(type="Xlib") graphics device, type X11Fonts() into the R console.

As well as graphical output to the screen, R can write the graphical output directly to a graphics file using R code. In addition, you can also write files using the "Cairo" graphics library for R, based on the device-independent and open-source Cairo graphics library, but, let's not worry about that for now!

Since sending graphical output to the screen is the default, you can get plotting without worrying about what graphical device your system is using.

If you are using the default R environment, when you generate a plot, it will appear on screen in a new window (the graphics device). If you were to generate a second plot, it would replace the previous plot with the new one in the same window. In RStudio, plots appear in a separate plot viewer, and you can scroll between different plots.

You can have multiple graphics devices on the screen at the same time (graphics windows).

To create a new screen device for the new plot, simply run the relevant device code before your plot code. For example:

# Windows systems:
# Open new screen device
windows()
### Plot code here ###

# MacOS: 
# Open new screen device
quartz()
### Plot code here ###

# Linux/UNIX systems:
# Open new screen device
x11()
### Plot code here ###

This works in the default R environment, and also RStudio where a new window will open showing the plot (rather than sending it to the plot viewer).

If you were to write a plot directly to a file (e.g. using the pdf() device), it would not appear on screen.

Plotting with base graphics: plot()

When using base graphics, or any default function to plot data, the main function you'll use for creating plots is plot(). This is a generic function which means it will use a different method for plotting data depending on the type or class of data (or object) you want to plot.

If you type methods(plot) into the R console, you'll get a list of the different plot methods that are available on your system (these may differ depending on what packages you have installed).

The methods may work differently and may have different arguments available. For example, check the help pages for ?plot and ?plot.default (type this in the R console) to see some of the differences.

For general usage, you don't really need to worry about this since plot() will call the right method automatically. However, its worth bearing in mind in case you run into any problems - check the object class, and check the help page for the plot method for that class.

When using plot(), the output is sent to the graphics device. This creates a "plot region" on the graphics device. The visible area of the graphics device is also known as the "device region". The plot region on the other hand is the area of the plot (usually bounded by a box), and does not include the plot axes, labels, or margins.

The plot region, plus the axes, labels and margins is known as the "figure region". Often, the device region and figure region can be the same size - but they are not the same thing.

Almost all kinds of plots, charts and graphs can be produced using base graphics, and these plots can be fully customised using par(), check out the help page (?par) for details of customisations.

This may seem confusing at first, and generally it is not something you need to worry about, unless you are creating multi panel plots, or heavily customising the plot. The diagram below illustrates these regions.

Plotting data in R

Now that you're more familiar with graphics in R, lets create a simple plot to show how easy it is in R. For these examples, we'll create some random data to plot.

# Set seed (to get the same random values)
set.seed(5431)
# Create random data
x <- rnorm(30) # 30 random numbers with a normal distribution
y <- rnorm(30)

In this code set.seed() is used so that the same "random" numbers can be created. rnorm() creates a set of random numbers with a normal distribution. x and y are the vectors containing the data.

To plot these two vectors, use the following code:

plot(x, y)

Which results in a simple scatter plot:

If the data was contained within a matrix or data frame, you could use the following code to plot:

# Create matrix
m <- matrix(c(x, y), ncol=2)
# Plot matrix
plot(m)

However, if the matrix or data frame contained more than two columns of data, you would also need to specify which columns to plot. For example:

# Specify data to be plotted
plot(m$x, m$y)

This code will plot the data from the column named "x" from the "m" matrix, against the data from the column named "y" from the "m" matrix.

This code is the equivalent of using:

# Specify data to be plotted
plot(m[,1], m[,2])

Which tells R to plot the first column of data (x axis) against the second column of data (y axis).

plot() arguments

Since plot() is a generic function, there are a lot of arguments available to control the plot, and these can vary depending on the type of plot you are creating.

For generic plotting, by default plot() will plot "points" to create a scatter plot (x y plot). You can change the plot type to join the points (line plots), or create bar or stair plots using the type argument.

Examples of each plot are below.

These are just the basic plot types available using plot(), which were created without any customisations, using minimal code. They are useful for quickly visualising data using minimal code. But, you can do so much more with graphics in R!

Here are a few of the available arguments you are likely to use with plot().

There are many more options available, and further customisations can be done by using par(). Check out the respective help pages for info.

Here's an example of a customised plot:

# Basic plot customisations
plot(x, y, type="b", col=rainbow(30), pch=18, cex=3, lty=2, lwd=2, main="My Plot", xlab="X axis", ylab="Y axis")

As well as these simple plots, you can create pretty much any type of plot or graphics that you can think of, either using base graphics, ggplot2, built-in functions or packages. This guide barely scratches the surface of what is possible, but it has hopefully given you a good overview of the basics.

Thanks for reading this guide and please leave any comments below.