```
library(tidyverse)
library(palmerpenguins)
library(gt)
```

# The grammar of graphics

This page is a summary of *A Layered Grammar of Graphics* by Hadley Wickham. I strongly encourage you to read the original article in conjunction with this summary.

Google defines a **grammar** as “the whole system and structure of a language or of languages in general, usually taken as consisting of syntax and morphology (including inflections) and sometimes also phonology and semantics”.^{1} Others consider a grammar to be “the fundamental principles or rules of an art or science”.^{2} Applied to visualizations, a **grammar of graphics** is a grammar used to describe and create a wide range of statistical graphics.^{3}

The **layered grammar of graphics** approach is implemented in `ggplot2`

, a widely used graphics library for R. All graphics in this library are built using a layered approach, building layers up to create the final graphic.

# Components of the layered grammar of graphics

- Layer
- Data
- Mapping
- Statistical transformation (stat)
- Geometric object (geom)
- Position adjustment (position)

- Scale
- Coordinate system (coord)
- Faceting (facet)
- Defaults
- Data
- Mapping

# Layer

**Layers** are used to create the objects on a plot. They are defined by five basic parts:

- Data
- Mapping
- Statistical transformation (stat)
- Geometric object (geom)
- Position adjustment (position)

Layers are typically related to one another and share many common features. For instance, multiple layers can be built using the same underlying data. An example would be a scatterplot overlayed with a smoothed regression line to summarize the relationship between two variables:

## Data and mapping

**Data** defines the source of the information to be visualized, but is independent from the other elements. So a layered graphic can be built which utilizes different data sources while keeping the other components the same.

For our running example, let’s use the `penguins`

dataset in the **palmerpenguins** package.^{4}

```
head(x = penguins) |>
gt() |>
tab_caption("The penguins dataset")
```

species | island | bill_length_mm | bill_depth_mm | flipper_length_mm | body_mass_g | sex | year |
---|---|---|---|---|---|---|---|

Adelie | Torgersen | 39.1 | 18.7 | 181 | 3750 | male | 2007 |

Adelie | Torgersen | 39.5 | 17.4 | 186 | 3800 | female | 2007 |

Adelie | Torgersen | 40.3 | 18.0 | 195 | 3250 | female | 2007 |

Adelie | Torgersen | NA | NA | NA | NA | NA | 2007 |

Adelie | Torgersen | 36.7 | 19.3 | 193 | 3450 | female | 2007 |

Adelie | Torgersen | 39.3 | 20.6 | 190 | 3650 | male | 2007 |

**Mapping** defines how the variables are applied to the plot. So if we were graphing information from `penguins`

, we might map a penguin’s flipper length to the \(x\) position and body mass to the \(y\) position.

```
|>
penguins select(flipper_length_mm, body_mass_g) |>
rename(
x = flipper_length_mm,
y = body_mass_g
)
```

```
# A tibble: 344 × 2
x y
<int> <int>
1 181 3750
2 186 3800
3 195 3250
4 NA NA
5 193 3450
6 190 3650
7 181 3625
8 195 4675
9 193 3475
10 190 4250
# ℹ 334 more rows
```

## Statistical transformation

A **statistical transformation** (*stat*) transforms the data, generally by summarizing the information. For instance, in a bar graph you typically are not trying to graph the raw data because this doesn’t make any inherent sense. Instead, you might summarize the data by graphing the total number of observations within a set of categories. Or if you have a dataset with many observations, you might transform the data into a smoothing line which summarizes the overall pattern of the relationship between variables by calculating the mean of \(y\) conditional on \(x\).

A stat is a function that takes in a dataset as the input and returns a dataset as the output; a stat can add new variables to the original dataset, or create an entirely new dataset. So instead of graphing this data in its raw form:

```
# A tibble: 344 × 1
island
<fct>
1 Torgersen
2 Torgersen
3 Torgersen
4 Torgersen
5 Torgersen
6 Torgersen
7 Torgersen
8 Torgersen
9 Torgersen
10 Torgersen
# ℹ 334 more rows
```

You would transform it to:

```
# A tibble: 3 × 2
island n
<fct> <int>
1 Biscoe 168
2 Dream 124
3 Torgersen 52
```

Sometimes you don’t need to make a statistical transformation. For example, in a scatterplot you use the raw values for the \(x\) and \(y\) variables to map onto the graph. In these situations, the statistical transformation is an *identity* transformation - the stat simply passes in the original dataset and exports the exact same dataset.

## Geometric objects

**Geometric objects** (*geoms*) control the type of plot you create. Geoms are classified by their dimensionality:

- 0 dimensions - point, text
- 1 dimension - path, line
- 2 dimensions - polygon, interval

Each geom can only display certain **aesthetics** or visual attributes of the geom. For example, a point geom has position, color, shape, and size aesthetics.

```
ggplot(
data = penguins,
mapping = aes(
x = flipper_length_mm,
y = body_mass_g,
color = species
)+
) geom_point() +
ggtitle("A point geom with position and color aesthetics")
```

- Position defines where each point is drawn on the plot
- Color defines the color of each point. Here the color is determined by the species of the car (observation)

Whereas a bar geom has position, height, width, and fill color.

```
ggplot(data = penguins, aes(x = island)) +
geom_bar() +
ggtitle("A bar geom with position and height aesthetics")
```

- Position determines the starting location (origin) of each bar
- Height determines how tall to draw the bar. Here the height is based on the number of observations in the dataset for each island.

## Position adjustment

Sometimes with dense data we need to adjust the position of elements on the plot, otherwise data points might obscure one another. Bar plots frequently **stack** or **dodge** the bars to avoid overlap:

```
ggplot(data = penguins, mapping = aes(x = island, fill = species)) +
geom_bar() +
ggtitle(label = "A stacked bar chart")
```

```
ggplot(data = penguins, mapping = aes(x = island, fill = species)) +
geom_bar(position = "dodge") +
ggtitle(label = "A dodged bar chart")
```

Sometimes scatterplots with few unique \(x\) and \(y\) values are **jittered** (random noise is added) to reduce overplotting.

```
ggplot(data = penguins, mapping = aes(x = island, y = body_mass_g)) +
geom_point() +
ggtitle("A point geom with obscured data points")
```

```
ggplot(data = penguins, mapping = aes(x = island, y = body_mass_g)) +
geom_jitter() +
ggtitle("A point geom with jittered data points")
```

# Scale

A **scale** controls how data is mapped to aesthetic attributes, so we need one scale for every aesthetic property employed in a layer. For example, this graph defines a scale for color:

```
ggplot(
data = penguins,
mapping = aes(
x = flipper_length_mm,
y = body_mass_g,
color = species
)+
) geom_point()
```

Note that the scale is consistent - every point for an Adèlie penguin is drawn in red, whereas Chinstrap penguins are drawn in green. The scale can be changed to use a different color palette:

```
ggplot(
data = penguins,
mapping = aes(
x = flipper_length_mm,
y = body_mass_g,
color = species
)+
) geom_point() +
scale_color_brewer(palette = "Dark2")
```

Now we are using a different palette, but the scale is still consistent: all Adèlie penguins utilize the same color, whereas Chinstrap penguins use a new color **but each Chinstrap penguin still uses the same, consistent color**.

# Coordinate system

A **coordinate system** (*coord*) maps the position of objects onto the plane of the plot, and controls how the axes and grid lines are drawn. Plots typically use two coordinates (\(x, y\)), but could use any number of coordinates. Most plots are drawn using the **Cartesian coordinate system**:

```
# generate a grid of points
<- expand_grid(
coord_df x = 1:10,
y = 1:5
)
# generate a simple plot with no data points, just the background
<- ggplot(data = coord_df, mapping = aes(x = x, y = y)) +
p geom_blank() +
theme_bw()
+
p ggtitle(label = "Cartesian coordinate system")
```

This system requires a fixed and equal spacing between values on the axes. That is, the graph draws the same distance between 1 and 2 as it does between 5 and 6. The graph could be drawn using a **semi-log coordinate system** which logarithmically compresses the distance on an axis:

```
+
p coord_trans(y = "log10") +
ggtitle(label = "Semi-log coordinate system")
```

Or could even be drawn using **polar coordinates**:

```
+
p coord_polar() +
ggtitle(label = "Polar coordinate system")
```

# Faceting

**Faceting** can be used to split the data up into subsets of the entire dataset. This is a powerful tool when investigating whether patterns are the same or different across conditions, and allows the subsets to be visualized on the same plot (known as **conditioned** or **trellis** plots). The faceting specification describes which variables should be used to split up the data, and how they should be arranged.

```
ggplot(data = penguins, mapping = aes(x = flipper_length_mm, y = body_mass_g)) +
geom_point() +
facet_wrap(facets = vars(species))
```

# Defaults

Rather than explicitly declaring each component of a layered graphic (which will use more code and introduces opportunities for errors), we can establish intelligent defaults for specific geoms and scales. For instance, whenever we want to use a bar geom, we can default to using a stat that counts the number of observations in each group of our variable in the \(x\) position.

Consider the following scenario: you wish to generate a scatterplot visualizing the relationship between flipper length and body mass. With no defaults, the code to generate this graph is:

```
ggplot() +
layer(
data = penguins, mapping = aes(x = flipper_length_mm, y = body_mass_g),
geom = "point", stat = "identity", position = "identity"
+
) scale_x_continuous() +
scale_y_continuous() +
coord_cartesian()
```

The above code:

- Creates a new plot object (
`ggplot()`

) - Adds a layer (
`layer()`

)- Specifies the data (
`penguins`

) - Maps flipper length to the \(x\) position and body mass to the \(y\) position (
`mapping`

) - Uses the point geometric transformation (
`geom = "point"`

) - Implements an identity transformation and position (
`stat = "identity"`

and`position = "identity"`

)

- Specifies the data (
- Establishes two continuous position scales (
`scale_x_continuous()`

and`scale_y_continuous()`

) - Declares a cartesian coordinate system (
`coord_cartesian()`

)

How can we simplify this using intelligent defaults?

- We only need to specify one geom and stat, since each geom has a default stat.
- Cartesian coordinate systems are most commonly used, so it should be the default.
- Default scales can be added based on the aesthetic and type of variables.
- Continuous values are transformed with a linear scaling.
- Discrete values are mapped to integers.
- Scales for aesthetics such as color, fill, and size can also be intelligently defaulted.

Using these defaults, we can rewrite the above code as:

```
ggplot() +
geom_point(data = penguins, mapping = aes(x = flipper_length_mm, y = body_mass_g))
```

This generates the exact same plot, but uses fewer lines of code. Because multiple layers can use the same components (data, mapping, etc.), we can also specify that information in the `ggplot()`

function rather than in the `layer()`

function:

```
ggplot(data = penguins, mapping = aes(x = flipper_length_mm, y = body_mass_g)) +
geom_point()
```

And as we will learn, function arguments in R use specific ordering, so we can omit the explicit call to `data`

and `mapping`

:

```
ggplot(penguins, aes(flipper_length_mm, body_mass_g)) +
geom_point()
```

With this specification, it is easy to build the graphic up with additional layers, without modifying the original code:

```
ggplot(penguins, aes(flipper_length_mm, body_mass_g)) +
geom_point() +
geom_smooth()
```

Because we called `aes(flipper_length_mm, body_mass_g)`

within the `ggplot()`

function, it is automatically passed along to both `geom_point()`

and `geom_smooth()`

. If we fail to do this, we get an error:

```
ggplot(penguins) +
geom_point(aes(flipper_length_mm, body_mass_g)) +
geom_smooth()
```

```
Error in `geom_smooth()`:
! Problem while computing stat.
ℹ Error occurred in the 2nd layer.
Caused by error in `compute_layer()`:
! `stat_smooth()` requires the following missing aesthetics: x and y
```

`::session_info() sessioninfo`

```
─ Session info ───────────────────────────────────────────────────────────────
setting value
version R version 4.3.1 (2023-06-16)
os macOS Ventura 13.5.2
system aarch64, darwin20
ui X11
language (EN)
collate en_US.UTF-8
ctype en_US.UTF-8
tz America/New_York
date 2024-01-11
pandoc 3.1.1 @ /Applications/RStudio.app/Contents/Resources/app/quarto/bin/tools/ (via rmarkdown)
─ Packages ───────────────────────────────────────────────────────────────────
package * version date (UTC) lib source
cli 3.6.2 2023-12-11 [1] CRAN (R 4.3.1)
codetools 0.2-19 2023-02-01 [1] CRAN (R 4.3.0)
colorspace 2.1-0 2023-01-23 [1] CRAN (R 4.3.0)
digest 0.6.33 2023-07-07 [1] CRAN (R 4.3.0)
dplyr * 1.1.4 2023-11-17 [1] CRAN (R 4.3.1)
evaluate 0.23 2023-11-01 [1] CRAN (R 4.3.1)
fansi 1.0.6 2023-12-08 [1] CRAN (R 4.3.1)
fastmap 1.1.1 2023-02-24 [1] CRAN (R 4.3.0)
forcats * 1.0.0 2023-01-29 [1] CRAN (R 4.3.0)
generics 0.1.3 2022-07-05 [1] CRAN (R 4.3.0)
ggplot2 * 3.4.4 2023-10-12 [1] CRAN (R 4.3.1)
glue 1.6.2 2022-02-24 [1] CRAN (R 4.3.0)
gt * 0.10.0 2023-10-07 [1] CRAN (R 4.3.1)
gtable 0.3.4 2023-08-21 [1] CRAN (R 4.3.0)
here 1.0.1 2020-12-13 [1] CRAN (R 4.3.0)
hms 1.1.3 2023-03-21 [1] CRAN (R 4.3.0)
htmltools 0.5.7 2023-11-03 [1] CRAN (R 4.3.1)
htmlwidgets 1.6.4 2023-12-06 [1] CRAN (R 4.3.1)
jsonlite 1.8.8 2023-12-04 [1] CRAN (R 4.3.1)
knitr 1.45 2023-10-30 [1] CRAN (R 4.3.1)
labeling 0.4.3 2023-08-29 [1] CRAN (R 4.3.0)
lifecycle 1.0.4 2023-11-07 [1] CRAN (R 4.3.1)
lubridate * 1.9.3 2023-09-27 [1] CRAN (R 4.3.1)
magrittr 2.0.3 2022-03-30 [1] CRAN (R 4.3.0)
munsell 0.5.0 2018-06-12 [1] CRAN (R 4.3.0)
palmerpenguins * 0.1.1 2022-08-15 [1] CRAN (R 4.3.0)
pillar 1.9.0 2023-03-22 [1] CRAN (R 4.3.0)
pkgconfig 2.0.3 2019-09-22 [1] CRAN (R 4.3.0)
purrr * 1.0.2 2023-08-10 [1] CRAN (R 4.3.0)
R6 2.5.1 2021-08-19 [1] CRAN (R 4.3.0)
readr * 2.1.4 2023-02-10 [1] CRAN (R 4.3.0)
rlang 1.1.2 2023-11-04 [1] CRAN (R 4.3.1)
rmarkdown 2.25 2023-09-18 [1] CRAN (R 4.3.1)
rprojroot 2.0.4 2023-11-05 [1] CRAN (R 4.3.1)
rstudioapi 0.15.0 2023-07-07 [1] CRAN (R 4.3.0)
scales 1.2.1 2024-01-06 [1] Github (r-lib/scales@c8eb772)
sessioninfo 1.2.2 2021-12-06 [1] CRAN (R 4.3.0)
stringi 1.8.3 2023-12-11 [1] CRAN (R 4.3.1)
stringr * 1.5.1 2023-11-14 [1] CRAN (R 4.3.1)
tibble * 3.2.1 2023-03-20 [1] CRAN (R 4.3.0)
tidyr * 1.3.0 2023-01-24 [1] CRAN (R 4.3.0)
tidyselect 1.2.0 2022-10-10 [1] CRAN (R 4.3.0)
tidyverse * 2.0.0 2023-02-22 [1] CRAN (R 4.3.0)
timechange 0.2.0 2023-01-11 [1] CRAN (R 4.3.0)
tzdb 0.4.0 2023-05-12 [1] CRAN (R 4.3.0)
utf8 1.2.4 2023-10-22 [1] CRAN (R 4.3.1)
vctrs 0.6.5 2023-12-01 [1] CRAN (R 4.3.1)
withr 2.5.2 2023-10-30 [1] CRAN (R 4.3.1)
xfun 0.41 2023-11-01 [1] CRAN (R 4.3.1)
xml2 1.3.6 2023-12-04 [1] CRAN (R 4.3.1)
yaml 2.3.8 2023-12-11 [1] CRAN (R 4.3.1)
[1] /Library/Frameworks/R.framework/Versions/4.3-arm64/Resources/library
──────────────────────────────────────────────────────────────────────────────
```

## Footnotes

Wickham, Hadley. (2010) “A Layered Grammar of Graphics”.

*Journal of Computational and Graphical Statistics*, 19(1)..↩︎Run

`?penguins`

in the console to get more information about this dataset.↩︎