The hardware and bandwidth for this mirror is donated by dogado GmbH, the Webhosting and Full Service-Cloud Provider. Check out our Wordpress Tutorial.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]dogado.de.

Introduction and Main Motivation

Original from author: “Emilio Torres-Manzanera” pulled from https://github.com/cran/xkcd/*

The XKCD web site is a web comic created by Randall Munroe, who described it as a web comic of romance, sarcasm, math, and language. He uses stick figures, very simple drawings composed of a few lines and curves, in his comics strips, that are available under the Creative Commons Attribution-NonCommercial 2.5 License.

Due to the popularity of Randall Munroe’s work, several questions about how to draw XKCD style graphs using different programming languages were posted in Stack Overflow. Many authors tried to replicate such style using different programming languages. For instance, there are implementations in Mathematica and Matlab using image processing distortion; a Python library focused on this style; and proposals in LaTeX.

The R language, despite being a software environment for statistical computing and graphics, lacked a specific package devoted to plot graphs in an XKCD style. To the best of our knowledge, there was not a satisfactory response to the question “How can we make xkcd style graphs in R?” published in Stack Overflow.

Fortunately, R is rich with facilities for creating and developing interesting graphics. In particular, the implementation of the grammar of graphics in R by ggplot2 allows the design of XKCD style graphs. The package xkcd presented in this paper develops several functions to plot statistical graphs in a freehand sketch style following the guidelines of the XKCD web site.

In this paper, an introduction to plot such graphs in R is detailed. The following section deals with installing xkcd fonts and saving graphs, a step that raised several questions among users. In the next section, some basic examples are explained, and the graph gallery section shows several complex plots. Finally, the article ends with a discussion concerning statistical information and creative drawing.

The XKCD Fonts

The package xkcd uses the XKCD fonts, so you must install them on your computer. An easy way to check whether these fonts are installed on the computer or not is typing the following code and comparing the results:

# Download xkcd font to a temporary location (do not ship the font with the package)
library(extrafont)
tryCatch({
  temp_font <- file.path(tempdir(), "xkcd.ttf")
  download.file("https://toledoem.github.io/img/xkcd.ttf",
                destfile = temp_font, mode = "wb", timeout = 60)
}, error = function(e) {
  warning("Failed to download xkcd font. See https://github.com/ipython/xkcd-font")
})

# If downloaded, copy into the user's fonts directory for registration (not packaged)
fonts_dir <- path.expand("~/.fonts")
if (!dir.exists(fonts_dir)) dir.create(fonts_dir, recursive = TRUE)
if (exists("temp_font") && file.exists(temp_font)) {
  file.copy(temp_font, file.path(fonts_dir, "xkcd.ttf"), overwrite = TRUE)
}

# Register fonts (import only when needed)
font_import(pattern = "[X/x]kcd", prompt = FALSE)
fonts()
fonttable()
if (.Platform$OS.type != "unix") {
  loadfonts(device = "win")
} else {
  loadfonts()
}
# Small font-check plot: uses installed xkcd font if available
library(extrafont)
library(ggplot2)
if ('xkcd' %in% extrafont::fonts()) {
  p <- ggplot() + geom_point(aes(x = mpg, y = wt), data = mtcars) +
    theme(text = element_text(size = 16, family = "xkcd"))
} else {
  warning("Not xkcd fonts installed!")
  p <- ggplot() + geom_point(aes(x = mpg, y = wt), data = mtcars)
}
p

# # Save initial font-check plot for README (if possible)
# try({
#   ggsave(filename = file.path("vignettes", "font_check.png"), plot = p, width = 6, height = 4)
# }, silent = TRUE)

If you want to modify these fonts, you may use the spline font database file format (sfd), the official xkcd font created by the IPython project and distributed under a Creative Commons Attribution-NonCommercial 3.0 License, which can be opened with FontForge, an open-source font editor.

Saving the Graphs

ggsave() is the preferred function for saving a ggplot2 plot. For instance, the following instruction saves the graph as a bitmap file:

ggsave("gr1.png", p)

If you want to save this chart as PDF you should embed the fonts into the PDF file, using embed_fonts(). First, if you are running Windows, you may need to tell it where the Ghostscript program is, for embedding fonts.

ggsave("gr1.pdf", plot = p, width = 12, height = 4)
if (.Platform$OS.type != "unix") {
  ## Needed for Windows. Make sure you have the correct path
  Sys.setenv(R_GSCMD =
              "C:\\Program Files (x86)\\gs\\gs9.06\\bin\\gswin32c.exe")
}
embed_fonts("gr1.pdf")

See the development site of extrafont for additional instructions and examples of using fonts other than the standard PostScript fonts.

Installing xkcd

The package xkcd is available on CRAN. From within R, you can install it with the following instruction:

install.packages("xkcd", dependencies = TRUE)

Once the package has been installed, it can be loaded by typing:

library(xkcd)

Automatically, it loads the packages ggplot2 and extrafont. The most relevant functions are xkcdaxis(), that plots axis in a handwritten style, xkcdman(), that draws stick figures, and xkcdrect(), that creates fuzzy rectangles. These functions are compatible with the grammar of graphics proposed by ggplot2.

From a technical point of view, lines plotted with the xkcd package are jittered with white noise and then smoothed using Bezier curves with the bezier() function from Hmisc.

Axis, Stick Figures, and Facets

In order to get a handmade drawing of the axis and an XKCD theme, a specific function based on the ggplot2 framework was created, xkcdaxis():

xrange <- range(mtcars$mpg)
yrange <- range(mtcars$wt)
set.seed(123)
p <- ggplot() + geom_point(aes(mpg, wt), data = mtcars) +
      xkcdaxis(xrange, yrange)
p

Due to the fact that white random noise is used in the picture, it is convenient to fix a seed for reproducing the same figure (set.seed()).

Maybe the most flashy function is xkcdman(), that draws a stick figure with different positions, angles, and lengths:

ightleg, angleleftleg = angleleftleg, angleofneck = angleofneck)

set.seed(123)
p <- ggplot() + geom_point(aes(x = mpg, y = wt, colour = as.character(vs)), data = mtcars) +
  xkcdaxis(xrange, yrange) +
  xkcdman(mapping, dataman)
p

Additionally, you may use the facet option of ggplot2 to split up your data by one or more variables and plot the subsets of data together.

p + facet_grid( ~ vs)

Some Basic Examples

In this section, the code to plot a line graph and a bar chart is detailed. Remember to set the seed if you want to replicate your own figures.

Line chart with stick figures

volunteers <- data.frame(year = c(2007:2011),
                         number = c(56470, 56998, 59686, 61783, 64251))
xrange <- range(volunteers$year)
yrange <- range(volunteers$number)
ratioxy <- diff(xrange) / diff(yrange)

dataman <- data.frame(x = c(2008, 2010), 
                      y = c(63000, 58850),
                      scale = 1000,
                      ratioxy = ratioxy,
                      angleofspine = -pi / 2,
                      anglerighthumerus = c(-pi / 6, -pi / 6),
                      anglelefthumerus = c(-pi / 2 - pi / 6, -pi / 2 - pi / 6),
                      anglerightradius = c(pi / 5, -pi / 5),
                      angleleftradius = c(pi / 5, -pi / 5),
                      anglerightleg = 3 * pi / 2 - pi / 12,
                      angleleftleg = 3 * pi / 2 + pi / 12,
                      angleofneck = -pi / 2)

mapping <- aes(x = x, y = y, scale = scale, ratioxy = ratioxy, 
               angleofspine = angleofspine,
               anglerighthumerus = anglerighthumerus, 
               anglelefthumerus = anglelefthumerus,
               anglerightradius = anglerightradius, 
               angleleftradius = angleleftradius,
               anglerightleg = anglerightleg, 
               angleleftleg = angleleftleg, 
               angleofneck = angleofneck)

set.seed(123)
p <- ggplot() + 
  geom_smooth(mapping = aes(x = year, y = number),
              data = volunteers, method = "loess", se = FALSE) +
  xkcdaxis(xrange, yrange) +
  ylab("Volunteers at Caritas Spain") +
  xkcdman(mapping, dataman) +
  annotate("text", x = 2008.7, y = 63700,
           label = "We Need\nVolunteers!", family = "xkcd") +
  annotate("text", x = 2010.5, y = 60000,
           label = "Sure\nI can!", family = "xkcd")

p

# Save a representative plot for README
try({
  ggsave(filename = file.path("caritas_plot.png"), plot = p, width = 9, height = 5)
}, silent = TRUE)

One interesting property of these charts is that when xkcd lines intersect, there is a space in blank in the crossing, following XKCD style.

Mommy jittered-text example

# Adapted from a legacy example: draw jittered 'Mummy' labels inside
# time-of-day boxes, add small xkcd-style ticks and save the figure as a PNG
mommy <- read.table(sep=" ",text ="
8 100
9 0
10 0
11 0
12 0
13 0
14 100
15 100
16 500
17 420
18 75
19 50
20 100
21 40
22 0
")
names(mommy) <- c("hour","number")
data <- mommy
data$xmin <- data$hour - 0.25
data$xmax <- data$xmin + 1
data$ymin <- 0
data$ymax <- data$number
xrange <- range(8, 24)
yrange <- range(min(data$ymin) + 10 , max(data$ymax) + 200)
ratioxy <- diff(xrange)/diff(yrange)

timelabel <-  function(text,x,y) {
  te1 <- annotate("text", x=x, y = y + 65, label=text, size = 6,family ="xkcd")
  list(te1,
       geom_xkcdpath(mapping = aes(x = xbegin, y = ybegin, xend = xend, yend = yend),
                      data = data.frame(xbegin = x, ybegin = y + 50, xend = x, yend = y),
                      xjitteramount = 0.5, linewidth = 0.8, mask = FALSE))
}

n <- 1800
set.seed(123)
x <- runif(n, xrange[1],xrange[2] )
y <- runif(n, yrange[1],yrange[2] )
inside <- unlist(lapply(1:n, function(i) any(data$xmin <= x[i] & x[i] < data$xmax &
                            data$ymin <= y[i] & y[i] < data$ymax)))
x <- x[inside]
y <- y[inside]

nman <- length(x)
sizer <- round(runif(nman, 1, 10),0)
angler <- runif(nman, -10,10)

p <- ggplot() +
  geom_text(aes(x,y,label="Mummy",angle=angler,hjust=0, vjust=0),
            family="xkcd",size=sizer,alpha=0.3) +
  xkcdaxis(xrange,yrange) +
  annotate("text", x=16, y = 650,
           label="Happy Mother's day", size = 16,family ="xkcd") +
  xlab("daily schedule") +
  ylab("Number of times mothers are called on by their children") +
  timelabel("Wake up", 9, 125) + timelabel("School", 12.5, 90) +
  timelabel("Lunch", 15, 130) +
  timelabel("Homework", 18, 525) +
  timelabel("Bath", 21, 110) +
  timelabel("zzz", 23.5, 60)

print(p)

# Save a PNG into the vignette folder so it can be used in the README
out_png <- file.path("mommy_plot.png")
ggsave(filename = out_png, plot = p, width = 9, height = 6)

You may specify the width, the height, and colors of the bars.

Discussion

Visualizing the data is an essential part of any data analysis, but the role graphics play to enlighten the audience means different things to different people. On the one hand, statisticians argue that graphic display needs to be clear, concise, and accurate; on the other hand, artists say that to be effective, it needs to be eye-catching, engaging, and innovative.

The book “The Visual Display of Quantitative Information” by Edward Tufte is a reference in the field of visual communication of information. Tufte coined the word “chartjunk” to refer to useless, non-informative, or information-obscuring elements of quantitative information displays and argues against using excessive decoration. Overloading your chart with XKCD elements may lead to loss of accuracy and the data visualization might become chartjunk.

In order to avoid this error, you must think about what the consumers of your graphs are looking for. Charts designed for business decisions and those designed for entertainment or education should not be the same. If you are trying to provoke or entertain, the XKCD style graphs may be suitable for your purpose and meaningful to your audience.

In summary, the package xkcd is a ggplot2 wrapper that makes graphs look like they came from an XKCD comic and it gives a satisfactory answer to the question “How can we make XKCD style graphs in R?”

Package Dependencies

The xkcd package relies on several key dependencies:

Key Functions Reference

xkcdaxis()

Plots axes in XKCD style with hand-drawn appearance.

xkcdaxis(xrange, yrange, ...)

Arguments: - xrange: Range of the X axis (vector of length 2) - yrange: Range of the Y axis (vector of length 2) - ...: Additional arguments passed to geom_xkcdpath

Returns: A list of layers including axes, coordinate system, and theme

xkcdman()

Draws a stick figure with customizable position and angles.

xkcdman(mapping, data, ...)

Arguments: - mapping: Aesthetic mapping generated by aes() with required aesthetics: x, y, scale, ratioxy, angleofspine, and angles for limbs and neck - data: Data frame containing figure parameters - ...: Additional arguments passed to geom_xkcdpath

Returns: A list of layers forming the stick figure

xkcdrect()

Draws fuzzy rectangles with hand-drawn borders.

xkcdrect(mapping, data, fillcolour = "grey90", bordercolour = "black",
         borderlinewidth = 0.5, borderxjitteramount = 0.005,
         borderyjitteramount = 0.005)

Arguments: - mapping: Aesthetic mapping with required aesthetics: xmin, xmax, ymin, ymax - data: Data frame with rectangle coordinates - fillcolour: Fill color of rectangles - bordercolour: Color of border lines - borderlinewidth: Width of border lines - borderxjitteramount: Horizontal jitter amount for borders - borderyjitteramount: Vertical jitter amount for borders

Returns: A list of layers with fill and border

geom_xkcdpath()

The core geom for drawing lines, segments, and circles in XKCD style.

geom_xkcdpath(mapping = NULL, data = NULL, stat = "identity", 
              position = "identity", ...,
              xjitteramount = NULL, yjitteramount = NULL, npoints = NULL, 
              ratioxy = NULL, bezier = FALSE, mask = FALSE, 
              na.rm = FALSE, show.legend = NA, inherit.aes = TRUE)

Key Arguments: - xjitteramount: Horizontal jitter amount for path points - yjitteramount: Vertical jitter amount for path points - npoints: Number of interpolation points - ratioxy: Ratio of x range to y range (for circles) - bezier: Apply Bezier smoothing - mask: Draw white mask underneath for hand-drawn effect - linewidth: Line stroke width (use this instead of the deprecated size aesthetic for lines) - group: Required aesthetic to properly group observations

Required aesthetics depend on geometry: - Segments: x, y, xend, yend - Circles: x, y, diameter - Paths: x, y

theme_xkcd()

Applies XKCD theme to ggplot2 plots.

theme_xkcd()

Returns: A ggplot2 theme object with XKCD styling

Tips and Tricks

  1. Always use set.seed() before creating plots with XKCD elements, as the jitter is random
  2. Include group aesthetics when using geom_xkcdpath() to avoid grouping warnings
  3. Adjust ratioxy parameter when drawing circles to ensure they appear circular
  4. Use mask = TRUE for segments to create the hand-drawn outline effect
  5. Consider readability when using XKCD style for business or academic presentations
  6. Embed fonts in PDF output using extrafont::embed_fonts() for portable documents

References

These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.
Health stats visible at Monitor.