8  Nobel Prize laureates: positioning text and parameterizing plots

In this chapter, we’ll learn how to access data through an API, create custom text layouts, and build parameterized plot functions.

Packages required in this chapter:

library(dplyr)
library(ggplot2)
library(glue)
library(ggtext)
library(lubridate)
library(readr)
library(showtext)
library(sysfonts)

8.1 Data

In this chapter, we’re going to explore Nobel Prize Laureates. Since 1901, the Nobel Prizes have been awarded to those who, during the preceding year, have conferred the greatest benefit to humankind. Awards are granted in the fields of Physics, Chemistry, Physiology or Medicine, Literature, Peace, and (since 1969) Economic Sciences.

In May 2019, the TidyTuesday challenge used several datasets about Nobel Prize Laureates and their publications. Those datasets contain data up to the year 2016. Since that data is now a little bit outdated, we’re going to look at an alternative way of obtaining the data and getting it into R - using an API!

An API (Application Programming Interface) is essentially a tool that lets different software programs communicate with each other (Harmon 2024). The Nobel Prize API endpoint (www.nobelprize.org 2024) can be accessed at api.nobelprize.org/2.1/laureates, with some instructions and guidance about how to use it available on the nobelprize.org website at www.nobelprize.org/organization/developer-zone-2, which also links to the Terms of Use.

This API doesn’t require an API key, so we don’t need to worry about registering, or authenticating an account. Instead, we simply pass the options into a URL and then read the CSV from that URL.

Let’s look at the data for just one of the fields to start with: Physics. There are lots of different options available for accessing the API, but we only need to specify a few of them:

• limit: how many results are returned. The default is 25 but there are more than 25 Nobel Laureates in physics so we need to use a higher value.
• nobelPrizeCategory: the field. The value is a three letter (lowercase) abbreviation for the field. For physics, the value is phy.
• format: the output format. The options are JSON or CSV, and we’ll use CSV since these files are easier to work with in R.

Tip 8.1: Choosing an API Limit

It’s important to be polite and not make too many API requests at once, so don’t choose 1,000 if you need 20 results.

If you have a limit of 250 requests and the data returned contains 250 results, you may want to check if you actually have all of the results!

We construct a URL in the following format: the base API URL, followed by the endpoint, followed by a ?, then a list of query parameters separated by &. Here, the base URL is http://api.nobelprize.org/2.1/ and the endpoint is laureates. You can either (1) build the URL as one long character string, or (2) construct the strings separately and stick them together with glue() as we’ve done here. If you are making multiple, slightly different, API calls then the second approach is more appropriate since you can re-use the base URL.

Once we’ve constructed the URL, we simply pass it into read_csv() from readr (or read.csv() from base R if you prefer) and save the output to a variable - nobel_physics in this case.

api_url <- "http://api.nobelprize.org/2.1/laureates"
nobel_physics <- read_csv(
  glue(
    "{api_url}?limit=250&nobelPrizeCategory=phy&format=csv"
  )
)

The data can also be accessed using the nobel R package (Rennie 2024b) which wraps the code above into the laureates() function.

We want to avoid querying the API multiple times if we don’t need to. Once we’ve downloaded the data, we can save it as a CSV file to allow us to use the data at a later point in time without re-querying the same query. We can use the write.csv() option to save the data to a file called nobel_physics.csv in an existing folder called data - you might choose to save it somewhere slightly different!

write.csv(
  nobel_physics,
  "data/nobel_physics.csv",
  row.names = FALSE
)

We can keep using the existing nobel_physics object, or we can read it back in from the CSV file using read_csv().

nobel_physics <- read_csv("data/nobel_physics.csv")

Let’s have a quick look at the data.

head(nobel_physics)

# A tibble: 6 × 13
     id name         gender birthdate  birthplace deathdate 
  <dbl> <chr>        <chr>  <date>     <chr>      <date>    
1   102 Aage N. Bohr male   1922-06-19 Copenhage… 2009-09-08
2   114 Abdus Salam  male   1926-01-29 Jhang Mag… 1996-11-21
3   866 Adam G. Rie… male   1969-12-16 Washingto… NA        
4  1012 Alain Aspect male   1947-06-15 Agen Fran… NA        
5    11 Albert A. M… male   1852-12-19 Strelno P… 1931-05-09
6    26 Albert Eins… male   1879-03-14 Ulm Germa… 1955-04-18
# ℹ 7 more variables: deathplace <chr>, category <chr>,
#   year <dbl>, share <chr>, overallmotivation <chr>,
#   motivation <chr>, affiliations <chr>

The data contains information for 13 variables for 226 laureates. The id column uniquely identifies a Nobel laureate. The name, gender, birthdate, birthplace, deathdate, and deathplace are fairly self-explanatory variables relating to the individual laureate. The category variable gives us the field of the award e.g. Physics. The year they were awarded the prize is given in the year column. Nobel Prizes can be shared among multiple people, and the share column indicates what fraction of the award each individual has. For example, a value of "1" for share indicates the individual was the sole recipient, and a value of "1/3" indicates they were one of three recipients.

The overallmotivation and motivation columns give an explanation of the reason why an individual was awarded the prize, There are many missing values in the overallmotivation column and, for those that do have a non-missing value, this appears to be a more general statement than the one given in motivation. The Nobel Laureates affiliations are also listed in the affiliations column.

8.2 Exploratory work

There are many different aspects of the data that we could explore: the demographics of the Nobel Laureates; how the geographical profile of awardees varies; or how the age of awardees has changed over time. Let’s have a look at the data to see if these are interesting questions to explore further.

8.2.1 Data exploration

Let’s start by exploring the relationship between year of birth and year of award. We would expect that the people born earlier in time, are also the people awarded Nobel Prizes earlier in time, and a scatter plot confirms this:

plot(
  x = nobel_physics$birthdate,
  y = nobel_physics$year,
  xlab = "Birth date",
  ylab = "Year of award"
)

Figure 8.1: A scatter plot of awardee birth date against year of award, showing the expected increasing trend.

We might be interested in seeing whether this relationship is changing over time. Essentially, is the age of awardees changing over time? We can use the year() function from lubridate to convert the birthdate into a year and subtract this from the award year to get an approximate age. Then plot this against the award year:

award_age <- nobel_physics$year -
  year(nobel_physics$birthdate)
plot(
  x = nobel_physics$year,
  y = award_age,
  xlab = "Year of award",
  ylab = "Age of Nobel Laureate"
)

Figure 8.2: A scatter plot showing the age of Nobel Prize awardees over time, with a slight increasing trend suggested.

It looks like the age of awardees might be increasing slightly - this could be interesting to explore further. But let’s also look at the gender split for Nobel Laureates in Physics. We can calculate the number of "male" and "female" values in the gender column using the table() function, then plot it using barplot():

barplot(table(nobel_physics$gender))

Figure 8.3: A bar chart of the number of male and female Nobel Laureates in Physics, with a much higher number of male awardees.

This is quite a significant difference! Let’s find a way to communicate and highlight this disparity.

8.2.2 Exploratory sketches

When thinking about how to construct a visualization, it’s important to consider multiple factors (Rennie and Krause 2024):

• What message are you trying to convey?
• Who are you trying to reach and what is their background?
• What is the purpose of the visualization?
• Does the way you’ve built that visualization support the purpose?

Let’s say that the purpose of the visualization is to highlight the gender disparity in Nobel Prize awardees. Yes, the bar chart of how many male and female Nobel Laureates there are shows the disparity very clearly. It’s a simple message. But it’s not eye-catching. It’s not a visualization that really makes a reader stop and pay attention. And it aggregates data down to just two categories - ignoring that these are individual people.

Instead, let’s think outside of the box are present the information in a very non-standard way:

Figure 8.4: Initial sketch of text arranged perpendicularly around a circle, with text color based on gender.

A bar chart would be a quicker, more efficient way of displaying how many male and female Nobel Laureates there are. A visualization of the names of every single Nobel Laureate might be a quicker, more efficient way of catching someone’s attention. This alternative visualization doesn’t sacrifice accuracy of information, but it might take a reader a little bit longer to digest the information. Whether that’s a sacrifice worth making comes back to what the purpose of the visualization is.

8.3 Preparing a plot

So let’s start making our custom visualization! We start by defining a variable for the award category we’re interested in - Physics. This first step might seem a little odd since we’ve only queried the API for physics data anyway, but when you get to the last section of this chapter, it’ll make more sense!

nobel_category <- "Physics"

It’s always worth double checking that we do actually only have the data we expect…

barplot(table(nobel_physics$category))

Figure 8.5: A bar chart of the number of Physics laureates (with a surprise appearance of a Chemistry laureate).

…because sometimes you find something unexpected!

Even though we’ve asked for only physics data from the API, the data also includes an entry relating to the Chemistry prize. If we read the documentation for the API, this gives us the explanation as to why. The API we’ve used relates to Nobel Laureates, not Nobel Prizes - meaning the list includes all laureates who have won a prize in Physics. Marie Curie won two Nobel Prizes - in 1903 for Physics, and in 1911 for Chemistry.

8.3.1 Data wrangling

We’ll start by using filter() from dplyr to filter out any non-Physics entries, and then selecting only the columns we need for our plot: name, gender, and year. The data is currently arranged alphabetically based on name, so we’ll use the arrange() function to sort by year.

physics_data <- nobel_physics |>
  filter(category == nobel_category) |>
  select(name, gender, year) |>
  arrange(year)

Now comes the tricky part of figuring out how to position the text in a circle. The first idea might be to simply plot the text in a line and then use the coord_polar() (or coord_radial()) function in ggplot2 to transform the coordinate space. However, coord_polar() makes it really hard to position other elements such as annotations on the plot. Alternatively, we could make use of the ggplot2 extension package, geomtextpath (Cameron and van den Brand 2024), which allows you to write text in ggplot2 that follows a curved path.

Tip 8.2: Why add annotations in R?

You may be wondering why we want to put so much work into building a custom layout from scratch, when you could easily just create a basic chart, apply coord_polar(), and then export it to other software (e.g. Inkscape or PowerPoint) to add the text annotations. This is certaintly a valid point. If you were only making a single chart on one occassion, then adding the finishing touches outside of R would be both quicker and easier. However, if you’re making the same chart multiple times, or creating slightly different versions of a similar chart, the manual work can quickly accumulate. The benefit of creating annotations in R is that it’s easier to scale up your work, and automate the annotation creation.

But (just for the fun of it) let’s try to make the plot from scratch using only ggplot2.

We need to define the following to be able to position the text:

• the x- and y- coordinates of where the text should end
• the angle that the text should be positioned at

To calculate the x- and y- coordinates, we want to start thinking in polar coordinates. To keep it simple, let’s assume that the circle which the text is positioned around is centered at (0, 0). For the coordinates, this means we need to know:

• the radius (r) of the circle: how far away from (0, 0) does the text start? This will be a constant value for all text labels.
• the angle (theta) of arc: how far round the circle from the horizontal axis should the text appear? This value will vary for each text label since we want the labels to be equally spaces around the (semi-)circle.

Let’s start by defining a variable for the radius. It doesn’t really matter what value you choose at this point since everything else can be re-scaled around a different radius.

r <- 5

Figure 8.6: Sketch showing the relationship between the radius, angle, and position of the text in x- and y-coordinates.

Assuming that we know the radius and angle of a point, we can calculate the x- and y- coordinates of a point using the following equations:

\[\begin{equation*} \begin{split} x & = r cos(\theta) \\ y & = r sin(\theta) \end{split} \end{equation*}\]

We don’t want to put the text all the way around the circle, since we want to leave some space to add the title as shown in Figure 8.4. We’ll leave a gap starting from \(\pi/4\) (between 1 and 2 on a clock face) to \(7\pi/4\) (between 4 and 5 on a clock face). We start by generating a sequence of equally spaced \(\theta\) values, starting from \(\pi/4\) and going to \(7\pi/4\), with one value for each observation in the data. This is added as a new column in the data using mutate() from dplyr. We then calculate the x and y coordinates using the equations above and, again, add these as new columns to the data.

The angle of the text is a little bit more tricky. We want the text to be positioned perpendicular to the circle i.e. the angle of the text is different for each name. We can use the value of theta to calculate the angle of the text.

When we later pass the angle value into ggplot2 functions for plotting, it’s expected that the angle be expressed in degrees (rather than radians). For example, for vertical text, we would pass in angle = 90 rather than angle = pi/2. So we need to transform theta to degrees by dividing by \(2\pi\) and multiplying by 360. To make the text the right way up (at least on the left side of the circle) we add 180 degrees.

plot_data <- physics_data |>
  mutate(
    theta = seq(
      from = pi / 4,
      to = (7 / 4) * pi,
      length.out = nrow(physics_data)
    ),
    x = r * cos(theta),
    y = r * sin(theta),
    angle = 180 + 360 * (theta / (2 * pi))
  )

Let’s have a quick look at the data:

head(plot_data)

# A tibble: 6 × 7
  name                  gender  year theta     x     y angle
  <chr>                 <chr>  <dbl> <dbl> <dbl> <dbl> <dbl>
1 Wilhelm Conrad Röntg… male    1901 0.785  3.54  3.54  225 
2 Hendrik A. Lorentz    male    1902 0.806  3.46  3.61  226.
3 Pieter Zeeman         male    1902 0.827  3.38  3.68  227.
4 Henri Becquerel       male    1903 0.849  3.31  3.75  229.
5 Marie Curie           female  1903 0.870  3.23  3.82  230.
6 Pierre Curie          male    1903 0.891  3.14  3.89  231.

Now we’re ready to start plotting with ggplot2!

8.3.2 The first plot

Constructing the base plot is reasonably straightforward - we’ve done the hard work in defining the x values, y values, the angles already. Since our plot is a visualization of text data, we’ll use geom_text() to add the text. All we have to do is tell ggplot2 what to put where!

We pass plot_data into the data argument, and then set the aesthetic mapping using aes(). The mappings are as you would expect: x goes on the x-axis, y goes on the y-axis, the label comes from the name column, the text angle is defined by the angle column we created, and the color is based on the values in the gender column. This mapping could be passed into either ggplot() or directly into geom_text() as we’ve done here. Since we’ll only be using one geometry for this plot, it won’t make a difference!

ggplot() +
  geom_text(
    data = plot_data,
    mapping = aes(
      x = x, y = y,
      label = name,
      angle = angle,
      color = gender
    )
  )

Figure 8.7: The names of Nobel Prize in Physics awardees arranged in a semi-circle, with color indicating awardee gender. The text is too large, creating many overlapping labels.

8.4 Advanced styling

At first glance, this first plot might look like a complete mess but with a little bit of work it will soon start looking like Figure 8.4.

8.4.1 Fonts

Let’s start by choosing some typefaces for our visualization. We’re going to pick two typefaces:

• title_font: a bold typeface that will, as the name suggests, be used for the title. We’ll use Passion One - a display typeface with thick, bold strokes which make it ideal for titles.
• a body_font: a simple typeface that will be used for all other text elements, including the text displaying the laureate names. This means the text will be quite a small font size, and so it’s important to use a clean and simple typeface. We’ll use Ubuntu - a sans serif typeface that we’ve used in previous chapters.

Both typefaces are provided through Google Fonts so we’ll use font_add_google() from sysfonts to load them into R. We also run showtext_auto() and showtext_opts(dpi = 300) to use showtext for rendering text on plots at our desired resolution.

font_add_google(name = "Passion One")
font_add_google(name = "Ubuntu")
showtext_auto()
showtext_opts(dpi = 300)
body_font <- "Ubuntu"
title_font <- "Passion One"

Now, let’s remake our basic_plot - this time also setting the font family to body_font. We’ll also right align the text using hjust = 1 to make the text appear around the outer edge of the circle. The text also needs to be a bit smaller to avoid overlapping between names positioned next to each other.

basic_plot <- ggplot() +
  geom_text(
    data = plot_data,
    mapping = aes(
      x = x, y = y,
      label = name,
      angle = angle,
      color = gender
    ),
    family = body_font,
    hjust = 1,
    size = 1
  )
basic_plot

Figure 8.8: The names of Nobel Prize in Physics awardees arranged in a semicircle, with color indicating awardee gender. Much of the text lies outside of the plot area.

8.4.2 Colors

As we’ve done in all previous chapters, we’ll define some variables for the colors we’ll be using in the visualization. Here, we’ll define a background color, a primary color, and a secondary color.

The primary color will be used to highlight the female laureates, as well as the title and caption text. The secondary color will be used to color the male laureate names. The primary color should be bolder or brighter than the secondary color - meaning a few pops of color on the chart will stand out and highlight the female laureates.

bg_col <- "gray95"
primary_col <- "black"
secondary_col <- "gray75"

We can apply these colors to the text showing the names using scale_color_manual() where we manually specify which color maps to which value in the gender column:

col_plot <- basic_plot +
  scale_color_manual(
    values = c(
      "male" = secondary_col,
      "female" = primary_col
    )
  )

8.4.3 Adding text

Rather than adding a title and subtitle at the top of the plot, we’ll add them in the gap in the right hand side of the circle. We’ll use the annotate() function from ggplot2 to add the text. Remember that for annotate(), we need to start by specifying the type of geometry we’re annotating - in this case, "text".

We’ll add two separate annotations: one for the title (Nobel Prize Laureates) and for a subtitle indicating the award category (Physics). The title and subtitle should be right-aligned, so we set the x-coordinate for each annotation to be equal to 10 and set hjust = 1. The title is vertically aligned with the center of the circle (at y = 0), and the subtitle slightly below it at y = -1. The font family is adjusted to either the body_font or title_font using the family argument, and the text size and color is also adjusted.

annotated_plot <- col_plot +
  annotate("text",
    x = 10, y = 0,
    label = "Nobel Prize Laureates",
    hjust = 1,
    color = primary_col,
    family = title_font,
    size = 7
  ) +
  annotate("text",
    x = 10, y = -1,
    label = nobel_category,
    hjust = 1,
    color = primary_col,
    family = body_font,
    size = 5
  )
annotated_plot

Figure 8.9: The names of Nobel Prize in Physics awardees arranged in a C-shape, with female awardees highlighted in a darker color. The text runs outside the plotting area, with annotations added to indicate the award category.

We can add a caption to the plot which contains: (i) a description of the data source, and (ii) the social media links from the social_caption() function we defined in Chapter 7. We make both the icons and text the same color - primary_col. We can pass this into the source_caption() function defined in Chapter 6.

social <- social_caption(
  icon_color = primary_col,
  font_color = primary_col,
  font_family = body_font
)
cap <- source_caption(
  source = "The Nobel Foundation",
  sep = "<br>",
  graphic = social
)

We then add this caption to our existing plot using the caption argument in the labs() function:

text_plot <- annotated_plot +
  labs(caption = cap)

8.4.4 Adjusting scales and themes

At the moment, the text isn’t arranged in a circle as such - it’s taking on more of an oval shape. To make sure it is displayed in a circle, we can use coord_fixed() to make sure that one unit on the x-axis is equal to one unit on the y-axis.

The limits of the plot also need to be extended. The scales are currently based on the x- and y- coordinates we passed in (the text at the inner edge of the circle) which means the text runs of the page. We can do this by extending the limits using scale_x_continuous() and scale_y_continuous(). We can extend the right hand side of the x-axis a little bit further to accommodate the added annotations.

styled_plot <- text_plot +
  scale_x_continuous(limits = c(-9, 12)) +
  scale_y_continuous(limits = c(-7.5, 7.5)) +
  coord_fixed()
styled_plot

Figure 8.10: The names of Nobel Prize in Physics awardees arranged around a circle, with female awardees highlighted in a darker color. The default grid lines remain in the background.

Since this is an artistic visualization, we want to remove the distracting grid lines and axis labels (which don’t make much sense for this type of plot). As we’ve done in earlier chapters (such as Chapter 12), we use theme_void() to remove these background theme elements.

We can some further, final customization by changing the following theme() elements:

• removing the legend
• changing the background color by passing in the bg_col variable to element_rect()
• using element_textbox_simple() from ggtext to format the HTML tags that add the social media icons in the caption

styled_plot +
  theme_void(base_size = 6, base_family = body_font) +
  theme(
    legend.position = "none",
    plot.background = element_rect(
      fill = bg_col, color = bg_col
    ),
    plot.caption = element_textbox_simple(
      color = primary_col,
      hjust = 0,
      halign = 0,
      lineheight = 0.5,
      margin = margin(l = 5, b = 5)
    )
  )

Figure 8.11: The names of Nobel Prize in Physics awardees arranged in an anti-clockwise direction, with female awardees highlighted in a darker color.

And we now have a creative way of visualizing the recipients of the Nobel Prize for Physics! How might we go about visualizing the recipients of the other prize categories in a similar way?

8.4.5 Parameterized plots

Although we could copy and paste the code we already have, and change out physics for peace everywhere, for example, this isn’t a sustainable approach if we’re not just looking to create one additional plot. What if we also want to create plots for medicine, economics, chemistry, and literature? That’s a lot of copy and pasting! Instead, we might want to think about creating our own function.

This can be really useful if, for example, you want to create a plot of sales performance for a given month. Let’s say last month you wanted to create a histogram of the sales for only last month. This month, you want to create the same histogram but with the data for only this month, Nothing other than the underlying data (and perhaps the title of the plot) should change. You could create a function that takes the month as an argument, filters the data, and then plots it with the updated title. You don’t have to rewrite the plotting code every month, you just need to call your custom plot function.

Throughout this book, we’ve been using variables to store our choice of colors, and typefaces. This makes it easier to quickly try out a new color scheme. But it also makes it easier to convert your code into a function: those variables just become function arguments!

When we’re converting our code into a function, we need to think about what a user has to tell us, in order for the code to work. In the sales histogram example above, a user would need to specify which month they want the plot for. In our example of the Nobel Prize visualizations, a user need to specify:

• which category they want to plot (we can’t read their mind or know what data they have)
• what the data is called (we don’t know what they’ve called their data.frame)
• the radius of the circle (we might need to vary this depending on how many observations are in a given category)

Tip 8.3: Checking columns exist

The data wrangling code assumes that year, name, gender, and category are columns that exist in the input data.frame. Since we’re working with data from an API that outputs it in a consistent format, this is a reasonable assumption to make. However, the API might change it some point. Or someone may want to use it with data sourced from somewhere else. To make the function more robust, we could add an initial step to check if those columns exist!

Now, we can also think about adding arguments that a user could specify:

• background color
• primary color
• secondary color
• body font
• title font

For these arguments, we can specify a default. This means that the function will work if a user doesn’t want to choose their own colors, but they are free to customize them if they choose to. None of these parameter choices make a fundamental difference to the plot created (other than how aesthetically pleasing it is).

Tip 8.4: Using fonts in functions

Here, we’ve specified that the default title typeface is "Passion One". A similar approach is used for the body typeface. Usually, such an approach is not recommended since there’s no guarantee that a user will have the "Passion One" typeface installed or loaded when running the function. This makes it a bad choice of default typeface.

We could add the font_add_google() code inside the function, but this also isn’t a good solution. We don’t want to re-install the fonts every time we run the function. A better option is to specify one of the integrated typefaces as a default e.g. title_font = "sans".

(Or at the very least, add instructions for how to load the typefaces you’ve used as a default!)

Now we can stitch together all the code we’ve used in this chapter, into the function body:

category_plot <- function(
    nobel_category,
    nobel_data,
    r = 5,
    bg_col = "gray95",
    primary_col = "black",
    secondary_col = "gray70",
    body_font = "Ubuntu",
    title_font = "Passion One") {
  # Data wrangling
  category_data <- nobel_data |>
    filter(category == nobel_category) |>
    select(name, gender, year) |>
    arrange(year)
  plot_data <- category_data |>
    mutate(
      theta = seq(
        from = pi / 4,
        to = (7 / 4) * pi,
        length.out = nrow(category_data)
      ),
      x = r * cos(theta),
      y = r * sin(theta),
      angle = 180 + 360 * (theta / (2 * pi))
    )
  # Text
  social <- social_caption(
    icon_color = primary_col,
    font_color = primary_col,
    font_family = body_font
  )
  cap <- source_caption(
    source = "The Nobel Foundation",
    sep = "<br>",
    graphic = social
  )
  # Plot
  g <- ggplot() +
    geom_text(
      data = plot_data,
      mapping = aes(
        x = x, y = y,
        label = name,
        angle = angle,
        color = gender
      ),
      family = body_font,
      hjust = 1,
      size = 1
    ) +
    scale_color_manual(
      values = c(
        "male" = secondary_col,
        "female" = primary_col
      )
    ) +
    annotate("text",
      x = 10, y = 0,
      label = "Nobel Prize Laureates",
      hjust = 1,
      color = primary_col,
      family = title_font,
      size = 7
    ) +
    annotate("text",
      x = 10, y = -1,
      label = nobel_category,
      hjust = 1,
      color = primary_col,
      family = body_font,
      size = 5
    ) +
    labs(caption = cap) +
    scale_x_continuous(limits = c(-9, 12)) +
    scale_y_continuous(limits = c(-7.5, 7.5)) +
    coord_fixed() +
    theme_void(base_size = 6, base_family = body_font) +
    theme(
      legend.position = "none",
      plot.background = element_rect(
        fill = bg_col, color = bg_col
      ),
      panel.background = element_rect(
        fill = bg_col, color = bg_col
      ),
      plot.caption = element_textbox_simple(
        color = primary_col,
        hjust = 0,
        halign = 0,
        lineheight = 0.5,
        margin = margin(l = 5, b = 5)
      )
    )
  return(g)
}

Now let’s test if our function works with a completely different set of data! Let’s use the Nobel Prize API again to download data on Nobel Peace Prize laureates. We edit the end of the API URL to use nobelPrizeCategory=pea (pea for peace) and then save the output to a CSV file, just as we did before for the physics data, this time using base R functions.

nobel_peace <- read.csv(
  glue(
    "{api_url}?limit=250&nobelPrizeCategory=pea&format=csv"
  )
)
write.csv(
  nobel_peace,
  "data/nobel_peace.csv",
  row.names = FALSE
)

Again, we can either keep working with the loaded data from the API, or read in the data from the CSV file:

nobel_peace <- read_csv("data/nobel_peace.csv")

Then we pass the "Peace" category into our category_plot() function, alongside out newly downloaded nobel_peace data. The nobel_peace data doesn’t have quite as many observations as the nobel_physics data, so we can reduce the radius (r) slightly and start the text a little bit closer to the middle of the circle. We can also choose some different colors for the visualization (but leave the defaults for the fonts):

peace_plot <- category_plot(
  "Peace",
  nobel_peace,
  r = 4,
  bg_col = "#FFEDE1",
  primary_col = "#8B1E3F",
  secondary_col = "#7286A0"
)
peace_plot

Figure 8.12: The names of Nobel Peace Prize awardees arranged in an anti-clockwise direction, with female awardees highlighted in pink.

What you might notice about this version of the chart is that a third color has appeared! In scale_color_manual(), we only specified which colors relate to "male" and "female" laureates. However, the Nobel Peace Prize can also be awarded to an organization, not just an individual. The (newly appeared) gray text relates to organisations listed in the nobel_peace data.

Tip 8.5: Building your own ggplot2 extension

Once you’ve built a custom chart type with core ggplot2 functions, you might be considering turning it into a ggplot2 extension package to make it easier for you and other people to use. The Everyday ggplot2 extension website (Reynolds 2025) provides advice and tutorials for building your first (or next) extension.

We can save a copy of the visualization using ggsave():

ggsave(
  filename = "peace-plot.png",
  plot = peace_plot,
  width = 5,
  height = 4
)

Tip 8.6: Circular text with ggtextcircle

The ggtextcircle package (Rennie 2024a) implements this type of visualization in a generic way - if you want to create something similar with a different data set!

8.5 Reflection

When we’re evaluating our visualizations, it’s important to remember the purpose for which we built it and evaluate how well it achieves that purposes. This visualization of the gender split of Nobel Laureates is not a standard plot that aims to communicate numbers as efficiently as possible.

There are a few standard aspects of this visualization we may wish to improve:

• It’s quite a hard visualization to understand without knowing what the colors and the order of the names represents. With a little bit of time and thought, a reader will likely pick out that the pink (for the Peace category plot) text represents female laureates. However, the ordering of the names in an anti-clockwise direction showing that the number of females laureates is generally increasing over time is much more difficult to pick up on. Add some text below the existing title and category label to explain how to interpret the visualization will help interested readers get the full message.

• It’s a minimal visualization by design. But that means it doesn’t tell a reader the whole story. As we discussed earlier, Nobel Prizes can be awarded to multiple individuals. However, this visualization only shows laureates, and not whether they shared the prize with anyone else. Are female laureates more or less likely to share a prize than their male counterparts? You can’t tell from this visualization.

• From a technical (or artistic) perspective, we might also want to consider alternative designs. For example, placing the text to the left of, or below, the circle rather than to the right. We may want to include the start and finish positions of the text around the circle as arguments to the parameterized function.

Despite the shortcomings when compared to more traditional visualizations, this approach is eye-catching and it does attract attention. Sometimes it’s not about the data visualization. Sometimes it’s about the art.

8.6 Exercises

• Edit the category_plot() to add another argument for the "Organisation" category. Make sure the function still works when there are no organisations in the data e.g. for the Physics data.

• Download data for another category e.g. Chemistry and use the category_plot() function again to create a version of the plot for that category.

Anscombe, F. J. 1973. “Graphs in Statistical Analysis.” The American Statistician 27 (1): 17–21. https://doi.org/10.1080/00031305.1973.10478966.

Aphalo, Pedro J. 2024. Learn R: As a Language. Second Edition. CRC Press. https://www.learnr-book.info/.

Auguie, Baptiste. 2019. egg: Extensions for ’ggplot2’: Custom Geom, Custom Themes, Plot Alignment, Labelled Panels, Symmetric Scales, and Fixed Panel Size. https://CRAN.R-project.org/package=egg.

Barthelme, Simon. 2024. imager: Image Processing Library Based on ’CImg’. https://CRAN.R-project.org/package=imager.

Bridson, Robert. 2007. “Fast Poisson Disk Sampling in Arbitrary Dimensions.” In ACM SIGGRAPH 2007 Sketches. SIGGRAPH ’07. New York, NY, USA: Association for Computing Machinery. https://doi.org/10.1145/1278780.1278807.

Brown, Mark J.F., and Paxton, Robert J. 2009. “The Conservation of Bees: A Global Perspective.” Apidologie 40 (3): 410–16. https://doi.org/10.1051/apido/2009019.

Cameron, Allan, and Teun van den Brand. 2024. geomtextpath: Curved Text in ’ggplot2’. https://CRAN.R-project.org/package=geomtextpath.

CARTO. 2016. ’CARTOColors’ Palettes. https://carto.com/carto-colors/.

Chang, Winston. 2023. extrafont: Tools for Using Fonts. https://CRAN.R-project.org/package=extrafont.

Cheung, Foo. 2021. dumbbell: Displaying Changes Between Two Points Using Dumbbell Plots. https://CRAN.R-project.org/package=dumbbell.

Comin, D. A., and B. Hobijn. 2009. “The CHAT Dataset.” Working Paper 15319. Working Paper Series. National Bureau of Economic Research. https://doi.org/10.3386/w15319.

Csárdi, Gábor, and Jim Hester. 2024. pak: Another Approach to Package Installation. https://CRAN.R-project.org/package=pak.

Csárdi, Gábor, Jim Hester, Hadley Wickham, Winston Chang, Martin Morgan, and Dan Tenenbaum. 2024. remotes: R Package Installation from Remote Repositories, Including ’GitHub’. https://CRAN.R-project.org/package=remotes.

Domin, Iaroslav. 2024. ggview: ’ggplot2’ Picture Previewer. https://CRAN.R-project.org/package=ggview.

Engler, Jan Broder. 2024. “Tidyplots Empowers Life Scientists with Easy Code-Based Data Visualization.” bioRxiv. https://doi.org/10.1101/2024.11.08.621836.

FC, Mike, Trevor L. Davis, and ggplot2 authors. 2024. ggpattern: ’ggplot2’ Pattern Geoms. https://CRAN.R-project.org/package=ggpattern.

Flaticon.com. 2024. “Wind Power Flaticon.” https://www.flaticon.com/free-icon/wind-power_5670189.

Font Awesome. 2024. “Font Awesome 6.” https://fontawesome.com/.

Franconeri, Steven L., Lace M. Padilla, Priti Shah, Jeffrey M. Zacks, and Jessica Hullman. 2021. “The Science of Visual Data Communication: What Works.” Psychological Science in the Public Interest 22 (3): 110–61. https://doi.org/10.1177/15291006211051956.

Garnier, Simon, Ross, Noam, Rudis, Robert, Camargo, et al. 2024. viridis(Lite) - Colorblind-Friendly Color Maps for R. https://doi.org/10.5281/zenodo.4679423.

Gohel, David, and Panagiotis Skintzos. 2024. ggiraph: Make ’ggplot2’ Graphics Interactive. https://CRAN.R-project.org/package=ggiraph.

Government Analysis Function. 2021. “Data Visualisation: Colours.”

Hafen, Ryan. 2023. geofacet: ’ggplot2’ Faceting Utilities for Geographical Data. https://CRAN.R-project.org/package=geofacet.

Harmon, Jon. 2024. Web APIs with R. CRC Press. https://wapir.io/.

Hester, Jim, Florent Angly, Russ Hyde, Michael Chirico, Kun Ren, Alexander Rosenstock, and Indrajeet Patil. 2024. lintr: A ’Linter’ for R Code. https://CRAN.R-project.org/package=lintr.

Hester, Jim, and Jennifer Bryan. 2024. glue: Interpreted String Literals. https://glue.tidyverse.org/.

Hughes, Ellis. 2022a. camcorder: Record Your Plot History. https://CRAN.R-project.org/package=camcorder.

———. 2022b. tidytuesdayR: Access the Weekly ’TidyTuesday’ Project Dataset. https://CRAN.R-project.org/package=tidytuesdayR.

Hvitfeldt, Emil. 2021. paletteer: Comprehensive Collection of Color Palettes. https://github.com/EmilHvitfeldt/paletteer.

Iannone, Richard. 2024. fontawesome: Easily Work with ’Font Awesome’ Icons. https://CRAN.R-project.org/package=fontawesome.

Internet Assigned Numbers Authority. 2023. “The tz Database: Time Zone and Daylight Saving Time Data.” Internet Assigned Numbers Authority. https://data.iana.org/time-zones/tz-link.html.

Jax (@lysrix). 2017. “Lemur.” https://unsplash.com/photos/red-and-white-rodent-h5xrh3CNT-k.

Kays, R., R. R. Dunn, A. W. Parsons, B. Mcdonald, T. Perkins, S. A. Powers, L. Shell, et al. 2020. “The Small Home Ranges and Large Local Ecological Impacts of Pet Cats.” Animal Conservation 23 (5): 516–23. https://doi.org/https://doi.org/10.1111/acv.12563.

Keyes, David. 2024. R for the Rest of Us: A Statistics-Free Introduction. No Starch Press. https://book.rfortherestofus.com/.

Lucchesi, Lydia, and Petra Kuhnert. 2020. Vizumap: Visualizing Uncertainty in Spatial Data. https://github.com/lydialucchesi/Vizumap.

Mapping Museums. 2021. “Mapping Museums Data.” www.mappingmuseums.org.

Massicotte, Philippe, and Andy South. 2023. rnaturalearth: World Map Data from Natural Earth. https://docs.ropensci.org/rnaturalearth/.

Matejka, Justin, and George Fitzmaurice. 2017. “Same Stats, Different Graphs: Generating Datasets with Varied Appearance and Identical Statistics Through Simulated Annealing.” In, 1290–94. https://doi.org/10.1145/3025453.3025912.

McDonald, J. L., and H. Cole. 2020. “Data from: The Small Home Ranges and Large Local Ecological Impacts of Pet Cats [United Kingdom].” Movebank data repository. https://doi.org/doi:10.5441/001/1.pf315732.

McWhite, Claire D., and Claus O. Wilke. 2024. colorblindr: Simulate colorblindness in R figures. https://github.com/clauswilke/colorblindr.

Mid-Atlantic Apiculture Research and Extension Consortium. 2024. “Seasonal Cycles of Activities in Colonies.”

mikefc. 2024. poissoned: Tileable Poisson Disc Sampling. https://github.com/coolbutuseless/poissoned.

Mills, Blake Robert. 2022. MetBrewer: Color Palettes Inspired by Works at the Metropolitan Museum of Art. https://CRAN.R-project.org/package=MetBrewer.

MIT Election Data and Science Lab. 2017. “U.S. House 1976–2022.” Harvard Dataverse. https://doi.org/10.7910/DVN/IG0UN2.

Müller, Kirill, and Lorenz Walthert. 2023. styler: Non-Invasive Pretty Printing of R Code. https://CRAN.R-project.org/package=styler.

Müller, Kirill, and Hadley Wickham. 2023. tibble: Simple Data Frames. https://CRAN.R-project.org/package=tibble.

Muth, Lisa. 2018. “An Alternative to Pink & Blue: Colors for Gender Data.”

Natural Resources Canada. 2021. “Canadian Wind Turbine Database.” Natural Resources Canada (Government of Canada). https://open.canada.ca/data/en/dataset/79fdad93-9025-49ad-ba16-c26d718cc070.

Nowosad, Jakub. 2018. ’CARTOColors’ Palettes. https://jakubnowosad.com/rcartocolor/.

Ooms, Jeroen. 2024. magick: Advanced Graphics and Image-Processing in R. https://CRAN.R-project.org/package=magick.

Our World in Data. 2019. “Medical Doctors Per 1,000 People.” https://ourworldindata.org/grapher/physicians-per-1000-people.

Pebesma, Edzer. 2018. “Simple Features for R: Standardized Support for Spatial Vector Data.” The R Journal 10 (1): 439–46. https://doi.org/10.32614/RJ-2018-009.

Pedersen, Thomas Lin. 2022. ggforce: Accelerating ’ggplot2’. https://CRAN.R-project.org/package=ggforce.

———. 2024. patchwork: The Composer of Plots. https://CRAN.R-project.org/package=patchwork.

———. 2025. “Fonts in R.” https://www.tidyverse.org/blog/2025/05/fonts-in-r/.

Pedersen, Thomas Lin, and Martin Mitáš. 2024. marquee: Markdown Parser and Renderer for R Graphics. https://CRAN.R-project.org/package=marquee.

Pedersen, Thomas Lin, Jeroen Ooms, and Devon Govett. 2024. systemfonts: System Native Font Finding. https://CRAN.R-project.org/package=systemfonts.

Pedersen, Thomas Lin, and Maxim Shemanarev. 2023. ragg: Graphic Devices Based on AGG. https://CRAN.R-project.org/package=ragg.

PLDB contributors. 2022. “PLDB: A Programming Language Database.” PLDB.

Qiu, Yixuan. 2022. sysfonts: Loading Fonts into R. https://CRAN.R-project.org/package=sysfonts.

———. 2023. showtext: Using Fonts More Easily in R Graphs. https://CRAN.R-project.org/package=showtext.

R Core Team. 2024. R: A Language and Environment for Statistical Computing. Vienna, Austria: R Foundation for Statistical Computing. https://www.R-project.org/.

R4DS Online Learning Community. 2023. “Tidy Tuesday: A Weekly Social Data Project.” https://github.com/rfordatascience/tidytuesday.

Rennie, Nicola. 2023a. “Adding Social Media Icons to Charts with ggplot2.” https://nrennie.rbind.io/blog/adding-social-media-icons-ggplot2/.

———. 2023b. “Creating Template Files with R.” https://nrennie.rbind.io/blog/script-templates-r/.

———. 2023c. “Four Ways to Streamline Your R Workflows.” https://nrennie.rbind.io/blog/four-ways-streamline-r-workflows/.

———. 2024a. ggtextcircle: Circular Text in ’ggplot2’. https://github.com/nrennie/ggtextcircle.

———. 2024b. nobel: Access data from the Nobel Prize API via R. https://github.com/nrennie/nobel.

———. 2024c. “tidytuesday.” GitHub Repository. GitHub. https://github.com/nrennie/tidytuesday.

Rennie, Nicola, and Andreas Krause. 2024. “Presenting data the Significance way - Part 1.” Significance 21 (3): 36–39. https://doi.org/10.1093/jrssig/qmae045.

Reynolds, Gina. 2025. “Everyday ggplot2 extension.” https://evamaerey.github.io/everyday_ggplot2_extension/.

RStudio. 2018a. “forcats Hex Sticker.” https://github.com/rstudio/hex-stickers/blob/main/PNG/forcats.png.

———. 2018b. “ggplot2 Hex Sticker.” https://github.com/rstudio/hex-stickers/blob/main/PNG/ggplot2.png.

———. 2018c. “purrr Hex Sticker.” https://github.com/rstudio/hex-stickers/blob/main/PNG/purrr.png.

———. 2018d. “readr Hex Sticker.” https://github.com/rstudio/hex-stickers/blob/main/PNG/readr.png.

———. 2018e. “tibble Hex Sticker.” https://github.com/rstudio/hex-stickers/blob/main/PNG/tibble.png.

———. 2020a. “dplyr Hex Sticker.” https://github.com/rstudio/hex-stickers/blob/main/PNG/dplyr.png.

———. 2020b. “stringr Hex Sticker.” https://github.com/rstudio/hex-stickers/blob/main/PNG/stringr.png.

———. 2020c. “tidyr Hex Sticker.” https://github.com/rstudio/hex-stickers/blob/main/PNG/tidyr.png.

Rudis, Bob, Ben Bolker, and Jan Schulz. 2017. ggalt: Extra Coordinate Systems, ’Geoms’, Statistical Transformations, Scales and Fonts for ’Ggplot2’. https://CRAN.R-project.org/package=ggalt.

Rudis, Bob, and Dave Gandy. 2023. waffle: Create Waffle Chart Visualizations. https://CRAN.R-project.org/package=waffle.

Sarkar, Deepayan. 2008. Lattice: Multivariate Data Visualization with r. New York: Springer. http://lmdvr.r-forge.r-project.org.

Schauberger, Philipp, and Alexander Walker. 2023. openxlsx: Read, Write and Edit xlsx Files. https://CRAN.R-project.org/package=openxlsx.

Scheuch, Christoph. 2025. owidapi: Access the Our World in Data Chart API. https://doi.org/10.32614/CRAN.package.owidapi.

Schloerke, Barret, Di Cook, Joseph Larmarange, Francois Briatte, Moritz Marbach, Edwin Thoen, Amos Elberg, and Jason Crowley. 2024. GGally: Extension to ’ggplot2’. https://CRAN.R-project.org/package=GGally.

Schloss, Karen B., Connor C. Gramazio, Allison T. Silverman, Madeline L. Parker, and Audrey S. Wang. 2019. “Mapping Color to Meaning in Colormap Data Visualizations.” IEEE Transactions on Visualization and Computer Graphics 25 (1): 810–19. https://doi.org/10.1109/TVCG.2018.2865147.

Shalloway, Bryan. 2023. funspotr: Spot R Functions & Packages. https://CRAN.R-project.org/package=funspotr.

Sievert, Carson. 2020. Interactive Web-Based Data Visualization with r, Plotly, and Shiny. Chapman; Hall/CRC. https://plotly-r.com.

Slowikowski, Kamil. 2024. ggrepel: Automatically Position Non-Overlapping Text Labels with ’ggplot2’. https://CRAN.R-project.org/package=ggrepel.

Tierney, Nicholas. 2017. “visdat: Visualising Whole Data Frames.” JOSS 2 (16): 355. https://doi.org/10.21105/joss.00355.

Tierney, Nicholas, and Dianne Cook. 2023. “Expanding Tidy Data Principles to Facilitate Missing Data Exploration, Visualization and Assessment of Imputations.” Journal of Statistical Software 105 (7): 1–31. https://doi.org/10.18637/jss.v105.i07.

Tol, Paul. 2021. “Paul Tol’s Notes: Colour schemes and templates.” https://personal.sron.nl/~pault/.

United States Census Bureau. 2021a. “Historical Population Change Data (1910-2020).”

———. 2021b. “State Area Measurements and Internal Point Coordinates.”

United States Department of Agriculture: Economics, Statistics and Market Information System. 2022. “Honey Bee Colonies.” USDA Economics, Statistics and Market Information System. https://usda.library.cornell.edu/concern/publications/rn301137d.

Walker, Kyle. 2022. Crsuggest: Obtain Suggested Coordinate Reference System Information for Spatial Data. https://CRAN.R-project.org/package=crsuggest.

Wanzer, Dana Linnell, Tarek Azzam, Natalie D. Jones, and Darrel Skousen. 2021. “The Role of Titles in Enhancing Data Visualization.” Evaluation and Program Planning 84: 101896. https://doi.org/https://doi.org/10.1016/j.evalprogplan.2020.101896.

Wickham, Hadley. 2016. ggplot2: Elegant Graphics for Data Analysis. Springer-Verlag New York. https://ggplot2.tidyverse.org.

———. 2023a. forcats: Tools for Working with Categorical Variables (Factors). https://doi.org/10.32614/CRAN.package.forcats.

———. 2023b. stringr: Simple, Consistent Wrappers for Common String Operations. https://CRAN.R-project.org/package=stringr.

Wickham, Hadley, Mara Averick, Jennifer Bryan, Winston Chang, Lucy D’Agostino McGowan, Romain François, Garrett Grolemund, et al. 2019. “Welcome to the tidyverse.” Journal of Open Source Software 4 (43): 1686. https://doi.org/10.21105/joss.01686.

Wickham, Hadley, and Jennifer Bryan. 2023. readxl: Read Excel Files. https://CRAN.R-project.org/package=readxl.

Wickham, Hadley, Mine Çetinkaya-Rundel, and Garrett Grolemund. 2023. R for Data Science. Second Edition. O-Reilly. https://r4ds.hadley.nz.

Wickham, Hadley, Romain François, Lionel Henry, Kirill Müller, and Davis Vaughan. 2023. dplyr: A Grammar of Data Manipulation. https://CRAN.R-project.org/package=dplyr.

Wickham, Hadley, and Lionel Henry. 2023. purrr: Functional Programming Tools. https://CRAN.R-project.org/package=purrr.

Wickham, Hadley, Jim Hester, and Jennifer Bryan. 2024. readr: Read Rectangular Text Data. https://CRAN.R-project.org/package=readr.

Wickham, Hadley, Thomas Lin Pedersen, and Dana Seidel. 2023. scales: Scale Functions for Visualization. https://CRAN.R-project.org/package=scales.

Wickham, Hadley, Davis Vaughan, and Maximilian Girlich. 2024. tidyr: Tidy Messy Data. https://CRAN.R-project.org/package=tidyr.

Wilke, Claus. 2022. ggtextures: Drawing Textured Rectangles and Bars with grid and ggplot2. https://github.com/clauswilke/ggtextures.

Wilke, Claus O. 2024. cowplot: Streamlined Plot Theme and Plot Annotations for ’ggplot2’. https://wilkelab.org/cowplot/.

Wilke, Claus O., and Brenton M. Wiernik. 2022. ggtext: Improved Text Rendering Support for ’ggplot2’. https://CRAN.R-project.org/package=ggtext.

www.nobelprize.org. 2024. “Nobel Prize API Version 2.1.” https://api.nobelprize.org/2.1/laureates.

York, Piers. 2023. owidR: Import Data from Our World in Data. <https://github.com/piersyork/owidR>.

Yu, Guangchuang. 2023. ggimage: Use Image in ’ggplot2’. https://CRAN.R-project.org/package=ggimage.

Yutani, Hiroaki. 2023. gghighlight: Highlight Lines and Points in ’ggplot2’. https://CRAN.R-project.org/package=gghighlight.

Zehr, Sarah M., Richard G. Roach, David Haring, Julie Taylor, Freda H. Cameron, and Anne D. Yoder. 2014. “Life history profiles for 27 strepsirrhine primate taxa generated using captive data from the Duke Lemur Center.” Scientific Data 1 (1). https://doi.org/10.1038/sdata.2014.19.